Update app.py

app.py

@@ -663,183 +663,145 @@ elif input_method == "Upload Image":
 # Updated code to convert frames to video file and display
 elif input_method == "Upload Video":
     uploaded_file = st.sidebar.file_uploader("Choose a video...", type=["mp4", "avi", "mov"])
-    
+
     if uploaded_file is not None:
-        # Save to temporary file
+        # Save uploaded file temporarily
         tfile = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
         tfile.write(uploaded_file.read())
         tfile_path = tfile.name
         tfile.close()
-        
+
         # Process button
         if st.sidebar.button("Process Video"):
             try:
                 cap = cv2.VideoCapture(tfile_path)
-                
+
                 if not cap.isOpened():
                     st.error("Cannot open video file")
                 else:
-                    # Get video info
                     fps = cap.get(cv2.CAP_PROP_FPS)
                     frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
                     frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
                     frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-                    
-                    # Store processing results
+
                     processed_frames = []
                     crash_frames = []
-                    
-                    # Process all frames first
+
                     progress_bar = st.progress(0)
                     status_text = st.empty()
-                    
                     status_text.text(f"Analyzing video... (0/{frame_count} frames)")
+
                     frame_number = 0
-                    
                     while True:
                         ret, frame = cap.read()
                         if not ret:
                             break
-                        
-                        # Process frame for detection
+
                         st.session_state.total_detections += 1
                         detection_result = detect_crash(frame)
-                        
-                        # Store processed frame and result
+
                         processed_frames.append({
                             "frame": detection_result["annotated_image"],
                             "result": detection_result
                         })
-                        
-                        # Track crash frames
+
                         if detection_result["crash_detected"]:
                             crash_frames.append({
                                 "frame_number": frame_number,
-                                "frame": frame.copy(),  # Store original frame for analysis
+                                "frame": frame.copy(),
                                 "detection_result": detection_result,
                                 "timestamp": time.time(),
                                 "severity": detection_result["severity"]
                             })
-                        
-                        # Update progress
+
                         frame_number += 1
                         if frame_number % 5 == 0 or frame_number == frame_count:
-                            # Update the progress bar and text
                             progress_value = min(frame_number / frame_count, 1.0)
                             progress_bar.progress(progress_value)
                             status_text.text(f"Analyzing video... ({frame_number}/{frame_count} frames)")
-                    
-                    # Close original video
+
                     cap.release()
-                    
+
+                    # Write processed frames to a new video file
                     status_text.text("Creating processed video...")
-                    
-                    # Create a temporary file in the system's temp directory
-                    timestamp = int(time.time())
-                    filename = f"processed_video_{timestamp}.mp4"
-                    temp_output_path = os.path.join(tempfile.gettempdir(), filename)
-                    
-                    # Create video writer
-                    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # Use mp4v codec which is widely compatible
-                    out = cv2.VideoWriter(
-                        temp_output_path, 
-                        fourcc, 
-                        fps, 
-                        (frame_width, frame_height)
-                    )
-                    
-                    # Write frames to video
-                    for frame_data in processed_frames:
-                        out.write(frame_data["frame"])
-                    
-                    # Release the writer
-                    out.release()
-                    
-                    # Verify file exists before proceeding
-                    if os.path.exists(temp_output_path) and os.path.getsize(temp_output_path) > 0:
-                        # Read the processed video into memory
-                        with open(temp_output_path, 'rb') as video_file:
-                            video_bytes = video_file.read()
-                        
-                        # Create a frame display interface
-                        display_option = st.radio(
-                            "Display Option",
-                            ["View Frames", "Download Video"],
-                            horizontal=True
-                        )
-                        
-                        if display_option == "View Frames":
-                            # Display frames with a slider
-                            st.write("Navigate through processed frames:")
-                            selected_frame = st.slider("Frame", 0, len(processed_frames)-1, 0)
-                            st.image(
-                                processed_frames[selected_frame]["frame"], 
-                                channels="BGR", 
-                                use_column_width=True,
-                                caption=f"Frame {selected_frame}"
-                            )
-                        else:
-                            # Provide a download button for the video
-                            st.download_button(
-                                label="Download Processed Video",
-                                data=video_bytes,
-                                file_name=filename,
-                                mime="video/mp4"
-                            )
-                            
-                            # Try to display the video directly as well
-                            try:
+                    output_video_path = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4').name
+
+                    if processed_frames:
+                        first_frame = processed_frames[0]["frame"]
+                        h, w = first_frame.shape[:2]
+
+                        fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # fallback codec
+                        out = cv2.VideoWriter(output_video_path, fourcc, fps, (w, h))
+
+                        for frame_data in processed_frames:
+                            out.write(frame_data["frame"])
+
+                        out.release()
+                        time.sleep(0.5)  # ensure video file is flushed
+
+                        try:
+                            with open(output_video_path, 'rb') as video_file:
+                                video_bytes = video_file.read()
+
+                            status_text.empty()
+                            progress_bar.empty()
+
+                            if "huggingface.co" in os.environ.get("HOST", "") or "SPACE_ID" in os.environ:
+                                # Display video using HTML for Hugging Face Spaces
+                                video_base64 = base64.b64encode(video_bytes).decode("utf-8")
+                                st.markdown(
+                                    f"""
+                                    <video width="100%" controls autoplay>
+                                        <source src="data:video/mp4;base64,{video_base64}" type="video/mp4">
+                                        Your browser does not support the video tag.
+                                    </video>
+                                    """,
+                                    unsafe_allow_html=True
+                                )
+                            else:
+                                # Local streamlit display
                                 st.video(video_bytes)
-                            except:
-                                st.info("Video preview not available. Please use the download button.")
-                        
-                        # Analysis complete, display results
-                        st.success(f"Video analysis complete. {len(processed_frames)} frames processed, {len(crash_frames)} crashes detected.")
-                    else:
-                        st.error(f"Failed to create video file at {temp_output_path}")
+
+                        except Exception as e:
+                            st.error(f"Error displaying video: {e}")
                     
-                    # After video display, process the last detected crash (if any)
+                    st.success(f"Video analysis complete. {len(processed_frames)} frames processed, {len(crash_frames)} crashes detected.")
+
                     if crash_frames:
-                        # Sort crash frames by frame number to find the latest
                         crash_frames.sort(key=lambda x: x["frame_number"])
-                        
-                        # Get the last crash frame
                         last_crash = crash_frames[-1]
-                        
-                        # Display the last crash frame
-                        frame_placeholder.image(last_crash["detection_result"]["annotated_image"], channels="BGR", 
-                                              caption=f"Last Detected Crash (Frame {last_crash['frame_number']})", 
-                                              use_column_width=True)
-                        
-                        # Now do the LLM analysis
+
+                        frame_placeholder.image(
+                            last_crash["detection_result"]["annotated_image"],
+                            channels="BGR",
+                            caption=f"Last Detected Crash (Frame {last_crash['frame_number']})",
+                            use_column_width=True
+                        )
+
                         with st.spinner("Analyzing crash severity..."):
                             crash_analysis = assess_crash_severity(last_crash["frame"], last_crash["detection_result"])
-                        
-                        # Set global variables
+
                         crash_detected = True
                         crash_severity = last_crash["severity"]
                         last_crash_time = last_crash["timestamp"]
-                        
-                        # Update crash statistics
+
                         st.session_state.total_crashes += len(crash_frames)
                         severe_count = sum(1 for crash in crash_frames if crash["severity"].lower() == "severe")
                         st.session_state.severe_crashes += severe_count
-                        
-                        # Update display with the last crash information
+
                         update_info_display(custom_analysis=crash_analysis)
-                        
-                        # Get current location
+
                         location = get_current_location()
-                        
-                        # Prepare crash data for alert
+
                         crash_data = {
                             "timestamp": datetime.fromtimestamp(last_crash_time).strftime('%Y-%m-%d %H:%M:%S'),
                             "severity": crash_severity,
+                            "analysis": crash_analysis,
                             "location": location,
+                            "raw_detection": last_crash["detection_result"]["raw_result"]
                         }
-                        
+
                         success, message = send_crash_alert_twilio(crash_data)
-                        
                         if success:
                             st.session_state.alerts_sent += 1
                             alert_status_placeholder.success(f"Alert sent: {message}")
@@ -847,23 +809,22 @@ elif input_method == "Upload Video":
                             alert_status_placeholder.error(f"Alert failed: {message}")
                     else:
                         st.info("No crashes detected in this video.")
-                    
-                    # Clean up temporary file
+
                     try:
-                        if os.path.exists(temp_output_path):
-                            os.remove(temp_output_path)
+                        os.remove(output_video_path)
                     except:
                         pass
+
             except Exception as e:
                 st.error(f"Error processing video: {e}")
-                st.exception(e)  # Show the full traceback for debugging
+                st.exception(e)
             finally:
-                # Clean up input file
                 try:
                     if os.path.exists(tfile_path):
                         os.remove(tfile_path)
                 except:
                     pass
+
 st.markdown("---")
 col1, col2, col3, col4 = st.columns(4)