Update app.py

app.py

@@ -1,712 +1,743 @@
-import streamlit as st
-import cv2
-import numpy as np
-import time
-import tempfile
-from PIL import Image
-import io
-import os
-import sys
-import threading
-from datetime import datetime
-import requests
-import google.generativeai as genai
-from ultralytics import YOLO
-import folium
-from streamlit_folium import folium_static
-import geocoder
-from twilio.rest import Client
-
-# Page configuration
-st.set_page_config(
-    page_title="Crash Detection System",
-    page_icon="🚨",
-    layout="wide"
-)
-
-# App title and description
-st.markdown("<h1 style='text-align: center; color: #FF4B4B;'>Vehicle Crash Detection System</h1>", unsafe_allow_html=True)
-st.markdown("""
-    <p style='text-align: center; font-size: 1.2em;'>Real-time vehicle crash detection and severity assessment</p>
-    """, unsafe_allow_html=True)
-
-# Sidebar for API key and Twilio configuration
-with st.sidebar.expander("API Configuration", expanded=False):
-    api_key = st.text_input("Google Gemini API Key", type="password")
-    if api_key:
-        genai.configure(api_key=api_key)
-        st.success("API key configured!")
-    else:
-        st.warning("Please enter your Google Gemini API key")
-
-with st.sidebar.expander("Twilio Configuration", expanded=False):
-    twilio_account_sid = st.text_input("Twilio Account SID", type="password")
-    twilio_auth_token = st.text_input("Twilio Auth Token", type="password")
-    twilio_from_number = st.text_input("Twilio From Number")
-    recipient_number = st.text_input("Recipient Phone Number")
-
-# BACKEND IMPLEMENTATION
-@st.cache_resource
-def load_model():
-    """Load the YOLO model with caching to avoid reloading"""
-    return YOLO("yolov8n.pt")
-
-# Get the model
-model = load_model()
-
-def detect_vehicles(image):
-    """
-    Detects vehicles in an image using YOLOv8.
-    
-    Args:
-        image: Either a numpy array (frame) or a path to an image file
-    
-    Returns:
-        List of detected vehicles, annotated image, and vehicle details
-    """
-    # Class IDs for vehicles we're interested in
-    vehicle_classes = {2: "Car", 3: "Motorcycle", 5: "Bus", 7: "Truck"}
-    detected_vehicles = []
-    vehicle_details = []
-    
-    # Process the image
-    results = model(image, conf=confidence_threshold, classes=[2, 3, 5, 7])  # Only detect vehicles
-    
-    # Extract detected vehicles
-    for result in results:
-        if hasattr(result, "boxes") and result.boxes is not None:
-            for box in result.boxes:
-                if hasattr(box, "cls") and box.cls is not None:
-                    cls = int(box.cls.item())
-                    if cls in vehicle_classes:
-                        vehicle_type = vehicle_classes[cls]
-                        confidence = float(box.conf.item())
-                        x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
-                        
-                        detected_vehicles.append(vehicle_type)
-                        vehicle_details.append({
-                            "type": vehicle_type,
-                            "confidence": confidence,
-                            "bbox": [x1, y1, x2, y2],
-                            "size": (x2-x1) * (y2-y1)  # Area of bounding box
-                        })
-    
-    # Get the annotated image with bounding boxes
-    annotated_frame = results[0].plot()
-    
-    return detected_vehicles, annotated_frame, vehicle_details
-
-def assess_crash_severity(image, detected_vehicles, vehicle_details):
-    """
-    Uses Google Gemini AI to assess crash severity in an image.
-    
-    Args:
-        image: PIL Image object
-        detected_vehicles: List of detected vehicles
-        vehicle_details: List of dictionaries with vehicle details
-    
-    Returns:
-        Severity assessment as a string, detailed analysis
-    """
-    if not api_key:
-        return "API key not configured for severity assessment", "No analysis available"
-    
-    if len(detected_vehicles) < 2:
-        return "No crash detected (insufficient vehicles)", "No analysis available"
-    
-    try:
-        # Convert to PIL Image if it's a numpy array
-        if isinstance(image, np.ndarray):
-            image_pil = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
-        else:
-            image_pil = image
-            
-        # Use Gemini to assess severity
-        model_gemini = genai.GenerativeModel("gemini-1.5-flash")
-        prompt = f"""
-        Analyze this image that shows a potential vehicle crash.
-        Detected vehicles: {', '.join(detected_vehicles)}
-        Vehicle details: {vehicle_details}
-        
-        Your task has two parts:
-        Give 2 Lines Short crisp Analysis
-        Analyze the crash severity in this image. Categorize the severity into: Minor or Severe 
-        """
-        
-        response = model_gemini.generate_content([prompt, image_pil])
-        
-        if response and hasattr(response, "text"):
-            response_text = response.text.strip()
-            
-            # Parse the response to get severity and analysis
-            if "SEVERITY:" in response_text and "ANALYSIS:" in response_text:
-                severity_part = response_text.split("ANALYSIS:")[0].replace("SEVERITY:", "").strip()
-                analysis_part = response_text.split("ANALYSIS:")[1].strip()
-                return severity_part, analysis_part
-            else:
-                return response_text, "No structured analysis available"
-        else:
-            return "Unable to assess severity", "No analysis available"
-            
-    except Exception as e:
-        return f"Error in severity assessment: {str(e)}", "Error in analysis"
-
-def get_current_location():
-    """
-    Get the current geolocation.
-    Returns approximate location as a dictionary with lat, lng, address
-    """
-    try:
-        g = geocoder.ip('me')
-        return {
-            "lat": g.lat,
-            "lng": g.lng,
-            "address": g.address
-        }
-    except Exception as e:
-        return {
-            "lat": 0,
-            "lng": 0,
-            "address": "Location unavailable"
-        }
-
-from twilio.rest import Client
-
-def send_crash_alert_twilio(crash_data):
-    """
-    Send a text message alert using Twilio
-
-    Args:
-        crash_data: Dictionary with crash details
-
-    Returns:
-        Boolean indicating success and message
-    """
-    messaging_service_sid = "MGf47912734231e47b941784b93376839d"
-    if not twilio_account_sid or not twilio_auth_token or not messaging_service_sid or not recipient_number:
-        return False, "Twilio configuration incomplete"
-
-    try:
-        # Initialize Twilio client
-        client = Client(twilio_account_sid, twilio_auth_token)
-
-        # Create message content
-        message_body = f"""
-        🚨 CRASH ALERT 🚨
-        Time: {crash_data['timestamp']}
-        Vehicles: {', '.join(crash_data['vehicles'])}
-        
-        """
-
-        # Send message using MessagingServiceSid
-        message = client.messages.create(
-            body=message_body,
-            from_=twilio_from_number,
-            messaging_service_sid="MGf47912734231e47b941784b93376839d",  # Matches curl request
-            to=recipient_number
-        )
-
-        return True, f"Message sent with SID: {message.sid}"
-
-    except Exception as e:
-        return False, f"Failed to send alert: {str(e)}"
-
-
-# FRONTEND IMPLEMENTATION
-# Create sidebar for controls
-st.sidebar.title("Controls")
-
-# Model selection
-detection_model = st.sidebar.selectbox(
-    "Select Detection Model",
-    ["YOLOv8n", "YOLOv8s", "YOLOv8m"],
-    index=0
-)
-
-# Detection settings
-confidence_threshold = st.sidebar.slider(
-    "Detection Confidence", 
-    min_value=0.0, 
-    max_value=1.0, 
-    value=0.45
-)
-
-# Input method selection
-input_method = st.sidebar.radio(
-    "Input Source",
-    ["Webcam", "Upload Image", "Upload Video"]
-)
-
-# Global variables for tracking detections
-last_crash_time = None
-crash_detected = False
-crash_severity = "None"
-crash_analysis = "None"
-detected_vehicles = []
-vehicle_details = []
-crash_alert_duration = 10  # seconds to show alert after crash detection
-latest_crash_image = None
-alert_sent_for_crash = False
-
-# Statistics
-if 'total_detections' not in st.session_state:
-    st.session_state.total_detections = 0
-if 'total_crashes' not in st.session_state:
-    st.session_state.total_crashes = 0
-if 'severe_crashes' not in st.session_state:
-    st.session_state.severe_crashes = 0
-if 'alerts_sent' not in st.session_state:
-    st.session_state.alerts_sent = 0
-
-# Create columns for the main display area
-col1, col2 = st.columns([2, 1])
-
-# Create a single map placeholder that will be populated only once
-map_container = st.container()
-
-# Image display area in column 1
-with col1:
-    frame_placeholder = st.empty()
-    # Initial image
-    sample_img = np.zeros((480, 640, 3), dtype=np.uint8)
-    frame_placeholder.image(sample_img, channels="BGR", use_column_width=True)
-
-# Info area in column 2
-with col2:
-    status_placeholder = st.empty()
-    vehicles_placeholder = st.empty()
-    severity_placeholder = st.empty()
-    analysis_placeholder = st.empty()
-    timestamp_placeholder = st.empty()
-    location_placeholder = st.empty()
-    alert_status_placeholder = st.empty()
-    
-    # Initialize displays
-    status_placeholder.markdown("""
-        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-            <h3>Status: Monitoring</h3>
-        </div>
-    """, unsafe_allow_html=True)
-    
-    vehicles_placeholder.markdown("""
-        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-            <h4>Detected Vehicles:</h4>
-            <p>None</p>
-        </div>
-    """, unsafe_allow_html=True)
-    
-    severity_placeholder.markdown("""
-        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-            <h4>Crash Severity:</h4>
-            <p>None</p>
-        </div>
-    """, unsafe_allow_html=True)
-    
-    analysis_placeholder.markdown("""
-        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-            <h4>Crash Analysis:</h4>
-            <p>None</p>
-        </div>
-    """, unsafe_allow_html=True)
-    
-    timestamp_placeholder.markdown("""
-        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-            <h4>Timestamp:</h4>
-            <p>N/A</p>
-        </div>
-    """, unsafe_allow_html=True)
-    
-    location_placeholder.markdown("""
-        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-            <h4>Location:</h4>
-            <p>N/A</p>
-        </div>
-    """, unsafe_allow_html=True)
-
-# Add a placeholder for the map in the map container
-with map_container:
-    map_placeholder = st.empty()
-    
-    # Initialize the map only once
-    initial_location = get_current_location()
-    m = folium.Map(location=[initial_location["lat"], initial_location["lng"]], zoom_start=15)
-    folium.Marker(
-        [initial_location["lat"], initial_location["lng"]],
-        popup="Current Location",
-        tooltip="Current Location"
-    ).add_to(m)
-    map_placeholder.empty()  # Clear initially, will be populated when needed
-
-def process_frame(frame):
-    """Process a single frame for crash detection"""
-    global crash_detected, crash_severity, crash_analysis, detected_vehicles, vehicle_details
-    global last_crash_time, latest_crash_image, alert_sent_for_crash
-    
-    try:
-        # Detect vehicles
-        vehicles, annotated_frame, vehicle_info = detect_vehicles(frame)
-        detected_vehicles = vehicles
-        vehicle_details = vehicle_info
-        
-        # Update total detections
-        if len(vehicles) > 0:
-            st.session_state.total_detections += 1
-        
-        # If multiple vehicles detected, check for crash
-        if len(vehicles) >= 2:
-            # Assess crash severity
-            severity, analysis = assess_crash_severity(frame, vehicles, vehicle_info)
-            
-            # If severity indicates a crash
-            if any(keyword in severity.lower() for keyword in ["minor", "moderate", "severe"]):
-                crash_detected = True
-                crash_severity = severity
-                crash_analysis = analysis
-                last_crash_time = time.time()
-                latest_crash_image = annotated_frame.copy()
-                alert_sent_for_crash = False
-                
-                # Update crash statistics
-                st.session_state.total_crashes += 1
-                if "severe" in severity.lower():
-                    st.session_state.severe_crashes += 1
-        
-        return annotated_frame
-        
-    except Exception as e:
-        st.error(f"Error processing frame: {e}")
-        return frame
-
-def send_crash_alert_if_needed():
-    """Send Twilio alert if crash is detected and alert not yet sent"""
-    global alert_sent_for_crash
-    
-    if crash_detected and not alert_sent_for_crash:
-        # Get current location
-        location = get_current_location()
-        
-        # Prepare crash data
-        crash_data = {
-            "timestamp": datetime.fromtimestamp(last_crash_time).strftime('%Y-%m-%d %H:%M:%S'),
-            "severity": crash_severity,
-            "analysis": crash_analysis,
-            "vehicles": detected_vehicles,
-            "vehicle_details": vehicle_details,
-            "location": location
-        }
-        
-        # Send alert
-        success, message = send_crash_alert_twilio(crash_data)
-        
-        if success:
-            alert_sent_for_crash = True
-            st.session_state.alerts_sent += 1
-            alert_status_placeholder.success(f"Alert sent: {message}")
-        else:
-            alert_status_placeholder.error(f"Alert failed: {message}")
-
-def update_info_display():
-    """Update the information display"""
-    global crash_detected, crash_severity, crash_analysis, detected_vehicles, last_crash_time
-    
-    # Check if crash alert should be active
-    current_time = time.time()
-    if last_crash_time and (current_time - last_crash_time > crash_alert_duration):
-        crash_detected = False
-    
-    # Update status
-    if crash_detected:
-        status_placeholder.markdown(f"""
-            <div style="padding: 10px; border-radius: 5px; background-color: #FF4B4B; color: white;">
-                <h3>Status: CRASH DETECTED! 🚨</h3>
-            </div>
-        """, unsafe_allow_html=True)
-    else:
-        status_placeholder.markdown("""
-            <div style="padding: 10px; border-radius: 5px; background-color: #4CAF50; color: white;">
-                <h3>Status: Monitoring</h3>
-            </div>
-        """, unsafe_allow_html=True)
-    
-    # Update vehicles
-    if detected_vehicles:
-        vehicles_html = "<br>".join([f"• {v}" for v in detected_vehicles])
-        vehicles_placeholder.markdown(f"""
-            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-                <h4>Detected Vehicles ({len(detected_vehicles)}):</h4>
-                <p>{vehicles_html}</p>
-            </div>
-        """, unsafe_allow_html=True)
-    else:
-        vehicles_placeholder.markdown("""
-            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-                <h4>Detected Vehicles:</h4>
-                <p>None</p>
-            </div>
-        """, unsafe_allow_html=True)
-    
-    # Update severity
-    if crash_detected:
-        severity_color = "#FF4B4B" if "severe" in crash_severity.lower() else "#FFA500"
-        severity_placeholder.markdown(f"""
-            <div style="padding: 10px; border-radius: 5px; background-color: {severity_color}; color: white;">
-                <h4>Crash Severity:</h4>
-                <p>{crash_severity}</p>
-            </div>
-        """, unsafe_allow_html=True)
-        
-        # Update analysis
-        analysis_placeholder.markdown(f"""
-            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-                <h4>Crash Analysis:</h4>
-                <p>{crash_analysis}</p>
-            </div>
-        """, unsafe_allow_html=True)
-    else:
-        severity_placeholder.markdown("""
-            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-                <h4>Crash Severity:</h4>
-                <p>None</p>
-            </div>
-        """, unsafe_allow_html=True)
-        
-        analysis_placeholder.markdown("""
-            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-                <h4>Crash Analysis:</h4>
-                <p>None</p>
-            </div>
-        """, unsafe_allow_html=True)
-    
-    # Update timestamp
-    if last_crash_time:
-        crash_time = datetime.fromtimestamp(last_crash_time).strftime('%Y-%m-%d %H:%M:%S')
-        timestamp_placeholder.markdown(f"""
-            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-                <h4>Last Crash Detected:</h4>
-                <p>{crash_time}</p>
-            </div>
-        """, unsafe_allow_html=True)
-        
-        # Update location
-        location = get_current_location()
-        location_placeholder.markdown(f"""
-            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-                <h4>Location:</h4>
-                <p>{location['address']}</p>
-            </div>
-        """, unsafe_allow_html=True)
-        
-        # Update map with crash location
-        m = folium.Map(location=[location["lat"], location["lng"]], zoom_start=15)
-        folium.Marker(
-            [location["lat"], location["lng"]],
-            popup=f"Crash Location<br>Severity: {crash_severity}<br>Time: {crash_time}",
-            tooltip="Crash Location",
-            icon=folium.Icon(color='red', icon='warning-sign')
-        ).add_to(m)
-        
-        # Only update the map once in the map container
-        with map_container:
-            folium_static(m)
-            
-        # Send alert if needed
-        send_crash_alert_if_needed()
-    else:
-        timestamp_placeholder.markdown("""
-            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-                <h4>Timestamp:</h4>
-                <p>N/A</p>
-            </div>
-        """, unsafe_allow_html=True)
-        
-        location_placeholder.markdown("""
-            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
-                <h4>Location:</h4>
-                <p>N/A</p>
-            </div>
-        """, unsafe_allow_html=True)
-
-# Handle different input methods
-if input_method == "Webcam":
-    # Add webcam selection
-    webcam_source = st.sidebar.selectbox(
-        "Select Camera",
-        ["0", "1", "2", "3"],
-        index=0
-    )
-    
-    start_button = st.sidebar.button("Start Detection")
-    stop_button = st.sidebar.button("Stop Detection")
-    
-    if start_button:
-        try:
-            cap = cv2.VideoCapture(int(webcam_source))
-            if not cap.isOpened():
-                st.error(f"Cannot open webcam {webcam_source}")
-            else:
-                st.session_state.webcam_running = True
-                
-                while st.session_state.webcam_running and not stop_button:
-                    ret, frame = cap.read()
-                    if not ret:
-                        st.error("Failed to capture frame from webcam")
-                        break
-                    
-                    # Process frame
-                    processed_frame = process_frame(frame)
-                    
-                    # Display the frame
-                    frame_placeholder.image(processed_frame, channels="BGR", use_column_width=True)
-                    
-                    # Update info display
-                    update_info_display()
-                    
-                    # Rerun to check for stop button
-                    time.sleep(0.1)
-                    
-                # Release resources
-                cap.release()
-                st.session_state.webcam_running = False
-        
-        except Exception as e:
-            st.error(f"Error accessing webcam: {e}")
-    
-    if stop_button and 'webcam_running' in st.session_state:
-        st.session_state.webcam_running = False
-        st.success("Detection stopped")
-
-elif input_method == "Upload Image":
-    uploaded_file = st.sidebar.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
-    
-    if uploaded_file is not None:
-        # Read image
-        image_bytes = uploaded_file.read()
-        image = cv2.imdecode(np.frombuffer(image_bytes, np.uint8), cv2.IMREAD_COLOR)
-        
-        # Display original image
-        frame_placeholder.image(image, channels="BGR", caption="Uploaded Image", use_column_width=True)
-        
-        # Process button
-        if st.sidebar.button("Process Image"):
-            # Process the image
-            processed_frame = process_frame(image)
-            
-            # Display processed image
-            frame_placeholder.image(processed_frame, channels="BGR", caption="Processed Image", use_column_width=True)
-            
-            # Update info display
-            update_info_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
-        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"):
-            stop_processing = st.sidebar.button("Stop Processing")
-            
-            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))
-                    
-                    # Add progress bar
-                    progress_bar = st.sidebar.progress(0)
-                    frame_number = 0
-                    
-                    # Process video
-                    st.session_state.video_running = True
-                    
-                    while st.session_state.video_running and not stop_processing:
-                        ret, frame = cap.read()
-                        if not ret:
-                            break
-                        
-                        # Process frame
-                        processed_frame = process_frame(frame)
-                        
-                        # Display the frame
-                        frame_placeholder.image(processed_frame, channels="BGR", use_column_width=True)
-                        
-                        # Update info display
-                        update_info_display()
-                        
-                        # Update progress
-                        frame_number += 1
-                        progress_bar.progress(min(frame_number / frame_count, 1.0))
-                        
-                        # Control playback speed
-                        time.sleep(0.1)  # Faster than real-time for quick processing
-                    
-                    # Release resources
-                    cap.release()
-                    
-                    # Clean up
-                    os.unlink(tfile_path)
-                    st.session_state.video_running = False
-                    
-            except Exception as e:
-                st.error(f"Error processing video: {e}")
-                try:
-                    os.unlink(tfile_path)
-                except:
-                    pass
-        
-        # Stop button
-        if st.sidebar.button("Stop", key="stop_video") and 'video_running' in st.session_state:
-            st.session_state.video_running = False
-            st.success("Processing stopped")
-
-# Add metrics/statistics section at the bottom
-st.markdown("---")
-col1, col2, col3, col4 = st.columns(4)
-
-with col1:
-    st.markdown(f"""
-        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0; text-align: center;">
-            <h4>Total Detections</h4>
-            <h2>{st.session_state.total_detections}</h2>
-        </div>
-    """, unsafe_allow_html=True)
-
-with col2:
-    st.markdown(f"""
-        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0; text-align: center;">
-            <h4>Total Crashes</h4>
-            <h2>{st.session_state.total_crashes}</h2>
-        </div>
-    """, unsafe_allow_html=True)
-
-with col3:
-    st.markdown(f"""
-        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0; text-align: center;">
-            <h4>Severe Crashes</h4>
-            <h2>{st.session_state.severe_crashes}</h2>
-        </div>
-    """, unsafe_allow_html=True)
-
-with col4:
-    st.markdown(f"""
-        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0; text-align: center;">
-            <h4>SMS Alerts Sent</h4>
-            <h2>{st.session_state.alerts_sent}</h2>
-        </div>
-    """, unsafe_allow_html=True)
-
-# Footer
-st.markdown("---")
-st.markdown("""
-    <p style='text-align: center;'>Vehicle Crash Detection and Severity Assessment System</p>
-    <p style='text-align: center;'>© 2025</p>
+import streamlit as st
+import cv2
+import numpy as np
+import time
+import tempfile
+from PIL import Image
+import io
+import os
+import sys
+import threading
+from datetime import datetime
+import requests
+import google.generativeai as genai
+import folium
+from streamlit_folium import folium_static
+import geocoder
+from twilio.rest import Client
+from inference_sdk import InferenceHTTPClient
+
+# Page configuration
+st.set_page_config(
+    page_title="Crash Detection System",
+    page_icon="🚨",
+    layout="wide"
+)
+
+# App title and description
+st.markdown("<h1 style='text-align: center; color: #FF4B4B;'>Vehicle Crash Detection System</h1>", unsafe_allow_html=True)
+st.markdown("""
+    <p style='text-align: center; font-size: 1.2em;'>Real-time vehicle crash detection and severity assessment</p>
+    """, unsafe_allow_html=True)
+
+# Sidebar for API key and Twilio configuration
+with st.sidebar.expander("API Configuration", expanded=False):
+    api_key = st.text_input("Google Gemini API Key", type="password",value="AIzaSyCcf3s3GS7_925D7t2fgODc5WIKOMZSOzc")
+    roboflow_api_key = st.text_input("Roboflow API Key", value="7pg4aR4pI1rxRJ4BTQo8", type="password")
+    if api_key:
+        genai.configure(api_key=api_key)
+        st.success("Google API key configured!")
+    if roboflow_api_key:
+        st.success("Roboflow API key configured!")
+
+with st.sidebar.expander("Twilio Configuration", expanded=False):
+    twilio_account_sid = st.text_input("Twilio Account SID", type="password")
+    twilio_auth_token = st.text_input("Twilio Auth Token", type="password")
+    twilio_from_number = st.text_input("Twilio From Number")
+    recipient_number = st.text_input("Recipient Phone Number")
+
+# BACKEND IMPLEMENTATION
+@st.cache_resource
+def initialize_roboflow_client():
+    """Initialize the Roboflow client with caching"""
+    return InferenceHTTPClient(
+        api_url="https://detect.roboflow.com",
+        api_key=roboflow_api_key
+    )
+
+# Get the client
+CLIENT = initialize_roboflow_client()
+
+def detect_crash(image):
+    """
+    Detects crashes in an image using Roboflow YOLO model
+    
+    Args:
+        image: PIL Image or numpy array
+    
+    Returns:
+        Dictionary with crash detection results, annotated image, and crash details
+    """
+    try:
+        # Convert to PIL Image if it's a numpy array
+        if isinstance(image, np.ndarray):
+            # Convert BGR (OpenCV) to RGB (PIL)
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            pil_image = Image.fromarray(image_rgb)
+        else:
+            pil_image = image
+            
+        # Save image temporarily with reduced quality for faster upload
+        temp_img_path = "temp_detection_image.jpg"
+        pil_image.save(temp_img_path, "JPEG", quality=70)
+        
+        # Send to Roboflow for inference
+        result = CLIENT.infer(temp_img_path, model_id="accident-yqljb/1")
+        
+        # Clean up temp file
+        if os.path.exists(temp_img_path):
+            os.remove(temp_img_path)
+        
+        # Initialize default response
+        crash_detected = False
+        severity = "None"
+        annotated_image = None
+        
+        # Create annotated image (with bounding boxes)
+        if isinstance(image, np.ndarray):
+            annotated_image = image.copy()
+        else:
+            annotated_image = np.array(pil_image)
+            # Convert back to BGR for OpenCV operations
+            annotated_image = cv2.cvtColor(annotated_image, cv2.COLOR_RGB2BGR)
+        
+        # Process predictions if available
+        if "predictions" in result and result["predictions"]:
+            for pred in result["predictions"]:
+                crash_detected = True
+                
+                # Extract severity based on class_id
+                class_id = pred.get("class_id", 0)
+                if class_id == 1:
+                    severity = "Minor"
+                elif class_id == 2:
+                    severity = "Moderate"
+                elif class_id == 3:
+                    severity = "Severe"
+                else:
+                    severity = "Unknown"
+                
+                # Draw bounding box on the image
+                x, y = pred.get("x", 0), pred.get("y", 0)
+                width, height = pred.get("width", 0), pred.get("height", 0)
+                confidence = pred.get("confidence", 0)
+                
+                # Calculate coordinates for rectangle
+                x1 = int(x - width/2)
+                y1 = int(y - height/2)
+                x2 = int(x + width/2)
+                y2 = int(y + height/2)
+                
+                # Ensure coordinates are within image bounds
+                img_height, img_width = annotated_image.shape[:2]
+                x1 = max(0, min(x1, img_width-1))
+                y1 = max(0, min(y1, img_height-1))
+                x2 = max(0, min(x2, img_width-1))
+                y2 = max(0, min(y2, img_height-1))
+                
+                # Set color based on severity
+                if severity == "Minor":
+                    color = (0, 255, 255)  # Yellow
+                elif severity == "Moderate":
+                    color = (0, 165, 255)  # Orange
+                else:
+                    color = (0, 0, 255)    # Red
+                
+                # Draw rectangle and label
+                cv2.rectangle(annotated_image, (x1, y1), (x2, y2), color, 2)
+                label = f"{severity} crash: {confidence:.2f}"
+                cv2.putText(annotated_image, label, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+        
+        return {
+            "crash_detected": crash_detected,
+            "severity": severity,
+            "annotated_image": annotated_image,
+            "raw_result": result
+        }
+    
+    except Exception as e:
+        st.error(f"Error in crash detection: {str(e)}")
+        # Return original image if error occurs
+        if isinstance(image, np.ndarray):
+            return {"crash_detected": False, "severity": "Error", "annotated_image": image, "raw_result": {}}
+        else:
+            return {"crash_detected": False, "severity": "Error", "annotated_image": np.array(pil_image), "raw_result": {}}
+
+def assess_crash_severity(image, crash_info):
+    """
+    Uses Google Gemini AI to assess crash severity in an image.
+    
+    Args:
+        image: PIL Image or numpy array
+        crash_info: Dictionary with crash detection results
+    
+    Returns:
+        Detailed analysis as a string
+    """
+    if not api_key:
+        return "API key not configured for detailed analysis"
+    
+    if not crash_info["crash_detected"]:
+        return "No crash detected in this image"
+    
+    try:
+        # Convert to PIL Image if it's a numpy array
+        if isinstance(image, np.ndarray):
+            image_pil = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+        else:
+            image_pil = image
+            
+        # Use Gemini to assess severity
+        model_gemini = genai.GenerativeModel("gemini-1.5-flash")
+        prompt = f"""
+        Analyze this vehicle crash image.
+        Detected crash severity: {crash_info['severity']}
+        Raw detection data: {crash_info['raw_result']}
+        
+        Give a short, 2-line analysis of the crash. Focus on:
+        1. Apparent damage level and potential injuries
+        2. Possible cause or contributing factors
+        
+        Keep your response concise and direct.
+        """
+        
+        response = model_gemini.generate_content([prompt, image_pil])
+        
+        if response and hasattr(response, "text"):
+            return response.text.strip()
+        else:
+            return "Unable to generate detailed analysis"
+            
+    except Exception as e:
+        return f"Error in analysis: {str(e)}"
+
+def get_current_location():
+    """
+    Get the current geolocation.
+    Returns approximate location as a dictionary with lat, lng, address
+    """
+    try:
+        g = geocoder.ip('me')
+        return {
+            "lat": g.lat,
+            "lng": g.lng,
+            "address": g.address
+        }
+    except Exception as e:
+        return {
+            "lat": 0,
+            "lng": 0,
+            "address": "Location unavailable"
+        }
+
+def send_crash_alert_twilio(crash_data):
+    """
+    Send a text message alert using Twilio
+
+    Args:
+        crash_data: Dictionary with crash details
+
+    Returns:
+        Boolean indicating success and message
+    """
+    messaging_service_sid = "MGf47912734231e47b941784b93376839d"
+    if not twilio_account_sid or not twilio_auth_token or not messaging_service_sid or not recipient_number:
+        return False, "Twilio configuration incomplete"
+
+    try:
+        # Initialize Twilio client
+        client = Client(twilio_account_sid, twilio_auth_token)
+
+        # Create message content
+        message_body = f"""
+        🚨 CRASH ALERT 🚨
+        Time: {crash_data['timestamp']}
+        Severity: {crash_data['severity']}
+        Location: {crash_data['location']['address']}
+        
+        Analysis: {crash_data['analysis']}
+        """
+
+        # Send message using MessagingServiceSid
+        message = client.messages.create(
+            body=message_body,
+            from_=twilio_from_number,
+            messaging_service_sid=messaging_service_sid,
+            to=recipient_number
+        )
+
+        return True, f"Message sent with SID: {message.sid}"
+
+    except Exception as e:
+        return False, f"Failed to send alert: {str(e)}"
+
+# FRONTEND IMPLEMENTATION
+# Create sidebar for controls
+st.sidebar.title("Controls")
+
+# Detection settings
+confidence_threshold = st.sidebar.slider(
+    "Detection Confidence", 
+    min_value=0.0, 
+    max_value=1.0, 
+    value=0.45
+)
+
+# Input method selection
+input_method = st.sidebar.radio(
+    "Input Source",
+    ["Webcam", "Upload Image", "Upload Video"]
+)
+
+# Global variables for tracking detections
+last_crash_time = None
+crash_detected = False
+crash_severity = "None"
+crash_analysis = "None"
+crash_alert_duration = 10  # seconds to show alert after crash detection
+latest_crash_image = None
+alert_sent_for_crash = False
+
+# Statistics
+if 'total_detections' not in st.session_state:
+    st.session_state.total_detections = 0
+if 'total_crashes' not in st.session_state:
+    st.session_state.total_crashes = 0
+if 'severe_crashes' not in st.session_state:
+    st.session_state.severe_crashes = 0
+if 'alerts_sent' not in st.session_state:
+    st.session_state.alerts_sent = 0
+
+# Create columns for the main display area
+col1, col2 = st.columns([2, 1])
+
+# Create a single map placeholder that will be populated only once
+map_container = st.container()
+
+# Image display area in column 1
+with col1:
+    frame_placeholder = st.empty()
+    # Initial image
+    sample_img = np.zeros((480, 640, 3), dtype=np.uint8)
+    frame_placeholder.image(sample_img, channels="BGR", use_column_width=True)
+
+# Info area in column 2
+with col2:
+    status_placeholder = st.empty()
+    severity_placeholder = st.empty()
+    analysis_placeholder = st.empty()
+    timestamp_placeholder = st.empty()
+    location_placeholder = st.empty()
+    alert_status_placeholder = st.empty()
+    
+    # Initialize displays
+    status_placeholder.markdown("""
+        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+            <h3>Status: Monitoring</h3>
+        </div>
+    """, unsafe_allow_html=True)
+    
+    severity_placeholder.markdown("""
+        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+            <h4>Crash Severity:</h4>
+            <p>None</p>
+        </div>
+    """, unsafe_allow_html=True)
+    
+    analysis_placeholder.markdown("""
+        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+            <h4>Crash Analysis:</h4>
+            <p>None</p>
+        </div>
+    """, unsafe_allow_html=True)
+    
+    timestamp_placeholder.markdown("""
+        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+            <h4>Timestamp:</h4>
+            <p>N/A</p>
+        </div>
+    """, unsafe_allow_html=True)
+    
+    location_placeholder.markdown("""
+        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+            <h4>Location:</h4>
+            <p>N/A</p>
+        </div>
+    """, unsafe_allow_html=True)
+
+# Add a placeholder for the map in the map container
+with map_container:
+    map_placeholder = st.empty()
+    
+    # Initialize the map only once
+    initial_location = get_current_location()
+    m = folium.Map(location=[initial_location["lat"], initial_location["lng"]], zoom_start=15)
+    folium.Marker(
+        [initial_location["lat"], initial_location["lng"]],
+        popup="Current Location",
+        tooltip="Current Location"
+    ).add_to(m)
+    map_placeholder.empty()  # Clear initially, will be populated when needed
+
+def handle_crash_detection(image, is_video=False, is_webcam=False):
+    """
+    Unified function to handle crash detection and all subsequent actions
+    
+    Args:
+        image: The image/frame to process
+        is_video: Whether this is from a video source
+        is_webcam: Whether this is from a webcam
+        
+    Returns:
+        Dictionary with results and whether to stop processing
+    """
+    global crash_detected, crash_severity, crash_analysis, last_crash_time, latest_crash_image, alert_sent_for_crash
+    
+    # Increment total detections
+    st.session_state.total_detections += 1
+    
+    # Detect crash
+    detection_result = detect_crash(image)
+    
+    # Update image with annotations
+    annotated_image = detection_result["annotated_image"]
+    frame_placeholder.image(annotated_image, channels="BGR", use_column_width=True)
+    
+    # If crash detected
+    if detection_result["crash_detected"]:
+        # Set global variables
+        crash_detected = True
+        crash_severity = detection_result["severity"]
+        last_crash_time = time.time()
+        latest_crash_image = annotated_image.copy()
+        alert_sent_for_crash = False
+        
+        # Get detailed analysis from Gemini
+        crash_analysis = assess_crash_severity(image, detection_result)
+        
+        # Update crash statistics
+        st.session_state.total_crashes += 1
+        if crash_severity.lower() == "severe":
+            st.session_state.severe_crashes += 1
+        
+        # Update info display
+        update_info_display()
+        
+        # Get current location
+        location = get_current_location()
+        
+        # Prepare crash data
+        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": detection_result["raw_result"]
+        }
+        
+        # Send alert
+        success, message = send_crash_alert_twilio(crash_data)
+        
+        if success:
+            alert_sent_for_crash = True
+            st.session_state.alerts_sent += 1
+            alert_status_placeholder.success(f"Alert sent: {message}")
+        else:
+            alert_status_placeholder.error(f"Alert failed: {message}")
+        
+        # Return result indicating whether to stop processing
+        return {
+            "crash_detected": True,
+            "should_stop": is_video and not is_webcam  # Stop if video but not webcam
+        }
+    else:
+        # Update info display for monitoring state
+        status_placeholder.markdown("""
+            <div style="padding: 10px; border-radius: 5px; background-color: #4CAF50; color: white;">
+                <h3>Status: Monitoring</h3>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        return {
+            "crash_detected": False,
+            "should_stop": False
+        }
+
+def update_info_display():
+    """Update the information display"""
+    global crash_detected, crash_severity, crash_analysis, last_crash_time
+    
+    # Check if crash alert should be active
+    current_time = time.time()
+    if last_crash_time and (current_time - last_crash_time > crash_alert_duration):
+        crash_detected = False
+    
+    # Update status
+    if crash_detected:
+        status_placeholder.markdown(f"""
+            <div style="padding: 10px; border-radius: 5px; background-color: #FF4B4B; color: white;">
+                <h3>Status: CRASH DETECTED! 🚨</h3>
+            </div>
+        """, unsafe_allow_html=True)
+    else:
+        status_placeholder.markdown("""
+            <div style="padding: 10px; border-radius: 5px; background-color: #4CAF50; color: white;">
+                <h3>Status: Monitoring</h3>
+            </div>
+        """, unsafe_allow_html=True)
+    
+    # Update severity
+    if crash_detected:
+        severity_color = "#FF4B4B" if crash_severity.lower() == "severe" else "#FFA500"
+        severity_placeholder.markdown(f"""
+            <div style="padding: 10px; border-radius: 5px; background-color: {severity_color}; color: white;">
+                <h4>Crash Severity:</h4>
+                <p>{crash_severity}</p>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        # Update analysis
+        analysis_placeholder.markdown(f"""
+            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+                <h4>Crash Analysis:</h4>
+                <p>{crash_analysis}</p>
+            </div>
+        """, unsafe_allow_html=True)
+    else:
+        severity_placeholder.markdown("""
+            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+                <h4>Crash Severity:</h4>
+                <p>None</p>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        analysis_placeholder.markdown("""
+            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+                <h4>Crash Analysis:</h4>
+                <p>None</p>
+            </div>
+        """, unsafe_allow_html=True)
+    
+    # Update timestamp
+    if last_crash_time:
+        crash_time = datetime.fromtimestamp(last_crash_time).strftime('%Y-%m-%d %H:%M:%S')
+        timestamp_placeholder.markdown(f"""
+            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+                <h4>Last Crash Detected:</h4>
+                <p>{crash_time}</p>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        # Update location
+        location = get_current_location()
+        location_placeholder.markdown(f"""
+            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+                <h4>Location:</h4>
+                <p>{location['address']}</p>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        # Update map with crash location
+        m = folium.Map(location=[location["lat"], location["lng"]], zoom_start=15)
+        folium.Marker(
+            [location["lat"], location["lng"]],
+            popup=f"Crash Location<br>Severity: {crash_severity}<br>Time: {crash_time}",
+            tooltip="Crash Location",
+            icon=folium.Icon(color='red', icon='warning-sign')
+        ).add_to(m)
+        
+        # Only update the map once in the map container
+        with map_container:
+            folium_static(m)
+    else:
+        timestamp_placeholder.markdown("""
+            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+                <h4>Timestamp:</h4>
+                <p>N/A</p>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        location_placeholder.markdown("""
+            <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0;">
+                <h4>Location:</h4>
+                <p>N/A</p>
+            </div>
+        """, unsafe_allow_html=True)
+
+# Handle different input methods
+if input_method == "Webcam":
+    # Add webcam selection
+    webcam_source = st.sidebar.selectbox(
+        "Select Camera",
+        ["0", "1", "2", "3"],
+        index=0
+    )
+    
+    start_button = st.sidebar.button("Start Detection")
+    stop_button = st.sidebar.button("Stop Detection")
+    
+    if start_button:
+        try:
+            cap = cv2.VideoCapture(int(webcam_source))
+            if not cap.isOpened():
+                st.error(f"Cannot open webcam {webcam_source}")
+            else:
+                st.session_state.webcam_running = True
+                
+                while st.session_state.webcam_running and not stop_button:
+                    ret, frame = cap.read()
+                    if not ret:
+                        st.error("Failed to capture frame from webcam")
+                        break
+                    
+                    # Process frame with unified handler
+                    result = handle_crash_detection(frame, is_video=True, is_webcam=True)
+                    
+                    # Rerun to check for stop button
+                    time.sleep(0.1)
+                    
+                # Release resources
+                cap.release()
+                st.session_state.webcam_running = False
+        
+        except Exception as e:
+            st.error(f"Error accessing webcam: {e}")
+    
+    if stop_button and 'webcam_running' in st.session_state:
+        st.session_state.webcam_running = False
+        st.success("Detection stopped")
+
+elif input_method == "Upload Image":
+    uploaded_file = st.sidebar.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+    
+    if uploaded_file is not None:
+        # Read image
+        image_bytes = uploaded_file.read()
+        image = cv2.imdecode(np.frombuffer(image_bytes, np.uint8), cv2.IMREAD_COLOR)
+        
+        # Display original image
+        frame_placeholder.image(image, channels="BGR", caption="Uploaded Image", use_column_width=True)
+        
+        # Process button
+        if st.sidebar.button("Process Image"):
+            # Process the image with unified handler
+            handle_crash_detection(image)
+
+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
+        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"):
+            stop_processing = st.sidebar.button("Stop Processing")
+            
+            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))
+                    
+                    # Add progress bar
+                    progress_bar = st.sidebar.progress(0)
+                    frame_number = 0
+                    
+                    # Process video
+                    st.session_state.video_running = True
+                    should_stop = False
+                    
+                    while st.session_state.video_running and not stop_processing and not should_stop:
+                        ret, frame = cap.read()
+                        if not ret:
+                            break
+                        
+                        # Process frame with unified handler
+                        result = handle_crash_detection(frame, is_video=True, is_webcam=False)
+                        should_stop = result["should_stop"]
+                        
+                        # If crash detected and it's a video, stop processing
+                        if should_stop:
+                            st.success("Crash detected! Video processing stopped.")
+                            break
+                        
+                        # Update progress
+                        frame_number += 1
+                        progress_bar.progress(min(frame_number / frame_count, 1.0))
+                        
+                        # Process frames faster than real-time
+                        time.sleep(0.05)
+                    
+                    # Release resources
+                    cap.release()
+                    
+                    # Clean up
+                    os.unlink(tfile_path)
+                    st.session_state.video_running = False
+                    
+                    # If video finished without crash detection
+                    if not should_stop and frame_number >= frame_count:
+                        st.info("Video processed. No crashes detected.")
+                    
+            except Exception as e:
+                st.error(f"Error processing video: {e}")
+                try:
+                    os.unlink(tfile_path)
+                except:
+                    pass
+        
+        # Stop button
+        if st.sidebar.button("Stop", key="stop_video") and 'video_running' in st.session_state:
+            st.session_state.video_running = False
+            st.success("Processing stopped")
+
+# Add metrics/statistics section at the bottom
+st.markdown("---")
+col1, col2, col3, col4 = st.columns(4)
+
+with col1:
+    st.markdown(f"""
+        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0; text-align: center;">
+            <h4>Total Detections</h4>
+            <h2>{st.session_state.total_detections}</h2>
+        </div>
+    """, unsafe_allow_html=True)
+
+with col2:
+    st.markdown(f"""
+        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0; text-align: center;">
+            <h4>Total Crashes</h4>
+            <h2>{st.session_state.total_crashes}</h2>
+        </div>
+    """, unsafe_allow_html=True)
+
+with col3:
+    st.markdown(f"""
+        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0; text-align: center;">
+            <h4>Severe Crashes</h4>
+            <h2>{st.session_state.severe_crashes}</h2>
+        </div>
+    """, unsafe_allow_html=True)
+
+with col4:
+    st.markdown(f"""
+        <div style="padding: 10px; border-radius: 5px; background-color: #f0f0f0; text-align: center;">
+            <h4>SMS Alerts Sent</h4>
+            <h2>{st.session_state.alerts_sent}</h2>
+        </div>
+    """, unsafe_allow_html=True)
+
+# Footer
+st.markdown("---")
+st.markdown("""
+    <p style='text-align: center;'>Vehicle Crash Detection and Severity Assessment System</p>
+    <p style='text-align: center;'>© 2025</p>
 """, unsafe_allow_html=True)