fixing camera n1235

src/streamlit_app.py

@@ -112,6 +112,10 @@ if 'current_image' not in st.session_state:
     st.session_state.current_image = None
 if 'demo_selected' not in st.session_state:
     st.session_state.demo_selected = False
+if 'processed_video_path' not in st.session_state:
+    st.session_state.processed_video_path = None
+if 'video_stats' not in st.session_state:
+    st.session_state.video_stats = None
 
 # Demo images URLs (publicly accessible images)
 DEMO_IMAGES = {
@@ -271,6 +275,71 @@ def process_image(image, model, conf_threshold):
     
     return rendered_img, relevant_detections, results
 
+def process_video(video_path, model, conf_threshold, frame_skip=1):
+    """Process video and return output path + stats."""
+    if model is None:
+        return None, None
+
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return None, None
+
+    fps = cap.get(cv2.CAP_PROP_FPS) or 24
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+    output_fd, output_path = tempfile.mkstemp(suffix=".mp4")
+    os.close(output_fd)
+
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 0
+    processed_frames = 0
+    detection_counts = {}
+
+    progress = st.progress(0, text="Processing video frames...")
+
+    frame_index = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        frame_index += 1
+        if frame_skip > 1 and frame_index % frame_skip != 0:
+            writer.write(frame)
+            continue
+
+        img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        model.conf = conf_threshold
+        results = model(img_rgb)
+
+        detections = results.pandas().xyxy[0]
+        relevant = detections[detections['name'].isin(WHEELCHAIR_CLASSES.values())]
+
+        for name in relevant['name'].tolist():
+            detection_counts[name] = detection_counts.get(name, 0) + 1
+
+        rendered_frame = results.render()[0]
+        writer.write(rendered_frame)
+
+        processed_frames += 1
+        if total_frames > 0:
+            progress.progress(min(processed_frames / total_frames, 1.0))
+
+    progress.empty()
+    cap.release()
+    writer.release()
+
+    stats = {
+        "total_frames": total_frames,
+        "processed_frames": processed_frames,
+        "detection_counts": detection_counts
+    }
+
+    return output_path, stats
+
 def create_detection_chart(detections):
     """Create a bar chart of detections"""
     if detections is None or len(detections) == 0:
@@ -417,13 +486,21 @@ def main():
         
         with col1:
             st.markdown("### 📷 Upload Image for Detection")
-            
+
             uploaded_file = st.file_uploader(
                 "Choose an image...",
                 type=['jpg', 'jpeg', 'png', 'bmp'],
                 help="Upload an image to test wheelchair navigation detection",
                 key="image_uploader"
             )
+
+            st.markdown("### 🎥 Upload Video for Detection")
+            uploaded_video = st.file_uploader(
+                "Choose a video...",
+                type=['mp4', 'avi', 'mov', 'mkv'],
+                help="Upload a video to run obstacle detection",
+                key="video_uploader"
+            )
             
             # Demo images buttons
             st.markdown("### 🎬 Or Try Demo Images")
@@ -466,6 +543,48 @@ def main():
             st.session_state.current_image = image
         elif st.session_state.demo_selected and st.session_state.current_image is not None:
             image = st.session_state.current_image
+
+        # Process uploaded video
+        if uploaded_video is not None:
+            st.session_state.demo_selected = False
+
+            if st.session_state.model is None:
+                with st.spinner("🤖 Loading AI model..."):
+                    st.session_state.model = load_model(conf_threshold)
+
+            if st.button("▶️ Run Video Detection", use_container_width=True):
+                with tempfile.NamedTemporaryFile(delete=False, suffix=Path(uploaded_video.name).suffix) as tmp:
+                    tmp.write(uploaded_video.getbuffer())
+                    tmp_path = tmp.name
+
+                with st.spinner("🔍 Processing video for obstacles..."):
+                    output_path, stats = process_video(tmp_path, st.session_state.model, conf_threshold, frame_skip=1)
+
+                st.session_state.processed_video_path = output_path
+                st.session_state.video_stats = stats
+
+                try:
+                    os.remove(tmp_path)
+                except Exception:
+                    pass
+
+            if st.session_state.processed_video_path:
+                st.markdown("### 🎬 Processed Video")
+                with open(st.session_state.processed_video_path, "rb") as f:
+                    st.video(f.read())
+
+            if st.session_state.video_stats:
+                st.markdown("### 📊 Video Detection Summary")
+                stats = st.session_state.video_stats
+                st.metric("🎞️ Total Frames", stats.get("total_frames", 0))
+                st.metric("✅ Processed Frames", stats.get("processed_frames", 0))
+
+                if stats.get("detection_counts"):
+                    counts_df = pd.DataFrame(
+                        sorted(stats["detection_counts"].items(), key=lambda x: x[1], reverse=True),
+                        columns=["Object", "Count"]
+                    )
+                    st.dataframe(counts_df, use_container_width=True)
         
         if image is not None: