webcam

app.py

@@ -257,6 +257,62 @@ def stop_video_inference():
     return "⏹️ Video processing stopped.", gr.update(interactive=True), gr.update(interactive=False)
 
 
+def run_webcam_inference(
+    frame: np.ndarray,
+    model_name: str,
+    confidence_threshold: float
+) -> Tuple[Image.Image, str]:
+    """
+    Process webcam stream - runs inference on captured camera frame.
+    
+    Args:
+        frame: Input frame from webcam as numpy array
+        model_name: Name of the model to use
+        confidence_threshold: Confidence threshold for filtering predictions
+    
+    Returns:
+        Tuple of (visualized_image, metrics_text)
+    """
+    if frame is None:
+        return None, "⚠️ No frame received from webcam."
+    
+    if model_name is None or model_name == "No models available":
+        return None, "⚠️ No model selected or available."
+    
+    try:
+        # Load or use cached model
+        model = load_model(model_name, confidence_threshold=confidence_threshold)
+        
+        # Run inference
+        result = model(frame)
+        
+        # Visualize results
+        visualized_image = visualizer.render(frame, result)
+        
+        # Get performance metrics
+        metrics = model.get_performance_metrics()
+        inference_time = metrics.get_inference_time()
+        preprocess_time = metrics.get_preprocess_time()
+        postprocess_time = metrics.get_postprocess_time()
+        fps = metrics.get_fps()
+        
+        # Format metrics text
+        metrics_text = f"""🔄 Preprocessing:  {preprocess_time.mean()*1000:.2f} ms
+⚙️  Inference:      {inference_time.mean()*1000:.2f} ms
+📊 Postprocessing: {postprocess_time.mean()*1000:.2f} ms
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+⏱️  Total Time:     {(preprocess_time.mean() + inference_time.mean() + postprocess_time.mean())*1000:.2f} ms
+🎯 FPS:            {fps:.2f}
+📈 Total Frames:   {inference_time.count}
+"""
+        
+        return visualized_image, metrics_text
+        
+    except Exception as e:
+        error_msg = f"Error during webcam inference: {str(e)}"
+        return None, error_msg
+
+
 def enable_video_buttons(video):
     """Enable start button when video is uploaded."""
     if video is not None:
@@ -488,6 +544,61 @@ def create_gradio_interface():
                     fn=run_video_inference,
                     cache_examples=True
                 )
+            
+            with gr.TabItem("📹 Live Inference"):
+                gr.Markdown("### Real-time inference using your webcam")
+                gr.Markdown("⚠️ **Note:** Allow browser access to your webcam when prompted.")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        webcam_input = gr.Image(
+                            sources=["webcam"],
+                            label="Webcam",
+                            type="numpy",
+                            streaming=True,
+                            show_label=False,
+                            height=400
+                        )
+                        
+                        webcam_model_dropdown = gr.Dropdown(
+                            choices=available_models,
+                            value=available_models[0] if available_models else None,
+                            label="Select Model",
+                            info="Choose a model from the models/ folder"
+                        )
+                        
+                        webcam_confidence_slider = gr.Slider(
+                            minimum=0.0,
+                            maximum=1.0,
+                            value=0.3,
+                            step=0.05,
+                            label="Confidence Threshold",
+                            info="Minimum confidence for displaying predictions"
+                        )
+                    
+                    with gr.Column(scale=1):
+                        webcam_output = gr.Image(
+                            label="Detection Result",
+                            type="pil",
+                            show_label=False,
+                            height=400
+                        )
+                        
+                        webcam_metrics_output = gr.Textbox(
+                            label="Performance Metrics",
+                            lines=8,
+                            max_lines=15
+                        )
+                
+                # Set up streaming from webcam
+                webcam_input.stream(
+                    fn=run_webcam_inference,
+                    inputs=[webcam_input, webcam_model_dropdown, webcam_confidence_slider],
+                    outputs=[webcam_output, webcam_metrics_output],
+                    time_limit=60,
+                    stream_every=0.1,
+                    concurrency_limit=16
+                )
     
     return demo