Upload 19 files

__init__.py

@@ -0,0 +1,39 @@
+"""
+Utils Package
+=============
+Utility functions for the Traffic Accident Reconstruction System.
+"""
+
+from .helpers import (
+    calculate_distance,
+    calculate_bearing,
+    interpolate_path,
+    estimate_speed_at_point,
+    find_intersection_point,
+    calculate_impact_angle,
+    estimate_stopping_distance,
+    format_duration,
+    format_speed,
+    format_distance,
+    validate_coordinates,
+    validate_speed,
+    generate_unique_id,
+    get_timestamp
+)
+
+__all__ = [
+    'calculate_distance',
+    'calculate_bearing',
+    'interpolate_path',
+    'estimate_speed_at_point',
+    'find_intersection_point',
+    'calculate_impact_angle',
+    'estimate_stopping_distance',
+    'format_duration',
+    'format_speed',
+    'format_distance',
+    'validate_coordinates',
+    'validate_speed',
+    'generate_unique_id',
+    'get_timestamp'
+]

accident_model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5d5e3dae6d3465e9b1cf71aabe3141b00300d962772cdd04b6d346cd1b910f4
+size 64081

components.py

@@ -0,0 +1,184 @@
+"""
+UI Components for Traffic Accident Reconstruction System
+========================================================
+Reusable Streamlit components for the application.
+"""
+
+import streamlit as st
+from config import CASE_STUDY_LOCATION, ALTERNATIVE_LOCATIONS
+
+
+def render_sidebar():
+    """Render the application sidebar."""
+    
+    with st.sidebar:
+        # MindSpore Logo at the top
+        try:
+            st.image("assets/mindspore_logo.png", width=120)
+        except:
+            st.markdown("### 🤖 MindSpore")
+        
+        st.markdown("---")
+        
+        st.header("🚗 Accident Analyzer")
+        
+        st.markdown("""
+        This system helps traffic authorities 
+        understand accidents through:
+        
+        - **AI-powered** scenario generation
+        - **Real map** visualization
+        - **2D simulation** of accidents
+        - **Probability analysis** of scenarios
+        """)
+        
+        st.markdown("---")
+        
+        st.subheader("📍 Case Study Location")
+        
+        st.info(f"""
+        **{CASE_STUDY_LOCATION['name']}**
+        
+        📍 {CASE_STUDY_LOCATION['city']}, {CASE_STUDY_LOCATION['country']}
+        
+        🗺️ Lat: {CASE_STUDY_LOCATION['latitude']:.4f}
+        🗺️ Lng: {CASE_STUDY_LOCATION['longitude']:.4f}
+        """)
+        
+        st.markdown("---")
+        
+        st.subheader("📚 Help")
+        
+        with st.expander("How to use"):
+            st.markdown("""
+            1. **Select Location**: View the roundabout location
+            2. **Vehicle 1**: Enter first vehicle details and draw its path
+            3. **Vehicle 2**: Enter second vehicle details and draw its path
+            4. **Analyze**: Let AI generate possible scenarios
+            5. **Results**: View scenarios with probability scores
+            """)
+        
+        with st.expander("About MindSpore"):
+            st.markdown("""
+            This system uses **Huawei MindSpore** 
+            for AI-powered scenario generation.
+            
+            MindSpore is an open-source deep 
+            learning framework optimized for 
+            Ascend processors.
+            """)
+        
+        st.markdown("---")
+        
+        st.caption("Huawei AI Innovation Challenge 2026")
+
+
+def render_header():
+    """Render the application header."""
+    
+    st.markdown("""
+    <div style="
+        background: linear-gradient(135deg, #1e3a5f 0%, #2d5a87 100%);
+        padding: 2rem;
+        border-radius: 10px;
+        color: white;
+        margin-bottom: 2rem;
+        text-align: center;
+    ">
+        <h1 style="margin: 0; font-size: 2.5rem;">🚗 Traffic Accident Reconstruction System</h1>
+        <p style="margin: 0.5rem 0 0 0; opacity: 0.9;">AI-Powered Analysis using Huawei MindSpore</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def render_footer():
+    """Render the application footer."""
+    
+    st.markdown("---")
+    
+    col1, col2, col3 = st.columns([2, 1, 2])
+    
+    with col1:
+        st.markdown("🏆 **Huawei AI Innovation Challenge 2026**")
+    
+    with col2:
+        # MindSpore logo in the center of footer
+        try:
+            st.image("assets/mindspore_logo.png", width=80)
+        except:
+            st.markdown("**[M]**")
+    
+    with col3:
+        st.markdown("🤖 **Powered by MindSpore AI Framework**")
+
+
+def render_info_card(title: str, content: str, color: str = "#2d5a87"):
+    """Render an information card."""
+    
+    st.markdown(f"""
+    <div style="
+        background: #f8f9fa;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid {color};
+        margin: 1rem 0;
+    ">
+        <h4 style="margin: 0 0 0.5rem 0;">{title}</h4>
+        <p style="margin: 0;">{content}</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def render_metric_card(label: str, value: str, delta: str = None, color: str = "#2d5a87"):
+    """Render a metric card."""
+    
+    delta_html = ""
+    if delta:
+        delta_color = "#28a745" if "+" in delta or "High" in delta else "#dc3545"
+        delta_html = f'<span style="color: {delta_color}; font-size: 0.9rem;">{delta}</span>'
+    
+    st.markdown(f"""
+    <div style="
+        background: rgba(255, 255, 255, 0.08);
+        backdrop-filter: blur(10px);
+        padding: 1.5rem;
+        border-radius: 12px;
+        border-top: 3px solid {color};
+        text-align: center;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.2);
+        border: 1px solid rgba(255, 255, 255, 0.12);
+    ">
+        <p style="margin: 0; color: rgba(255, 255, 255, 0.7); font-size: 0.9rem; font-weight: 500;">{label}</p>
+        <h2 style="margin: 0.5rem 0; color: {color}; font-weight: 700;">{value}</h2>
+        {delta_html}
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def render_progress_bar(value: float, label: str = "", color: str = "#2d5a87"):
+    """Render a custom progress bar."""
+    
+    percentage = min(max(value * 100, 0), 100)
+    
+    st.markdown(f"""
+    <div style="margin: 0.5rem 0;">
+        <div style="display: flex; justify-content: space-between; margin-bottom: 0.25rem;">
+            <span>{label}</span>
+            <span>{percentage:.1f}%</span>
+        </div>
+        <div style="
+            background: #e9ecef;
+            border-radius: 5px;
+            height: 20px;
+            overflow: hidden;
+        ">
+            <div style="
+                background: {color};
+                width: {percentage}%;
+                height: 100%;
+                border-radius: 5px;
+                transition: width 0.3s ease;
+            "></div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)

helpers.py

@@ -0,0 +1,287 @@
+"""
+Utility Functions
+=================
+Helper functions for the Traffic Accident Reconstruction System.
+"""
+
+import numpy as np
+from typing import List, Tuple, Dict, Any
+from datetime import datetime
+import math
+
+
+def calculate_distance(point1: List[float], point2: List[float]) -> float:
+    """
+    Calculate the Haversine distance between two geographic points.
+    
+    Args:
+        point1: [latitude, longitude]
+        point2: [latitude, longitude]
+    
+    Returns:
+        Distance in meters
+    """
+    R = 6371000  # Earth's radius in meters
+    
+    lat1, lon1 = math.radians(point1[0]), math.radians(point1[1])
+    lat2, lon2 = math.radians(point2[0]), math.radians(point2[1])
+    
+    dlat = lat2 - lat1
+    dlon = lon2 - lon1
+    
+    a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
+    c = 2 * math.asin(math.sqrt(a))
+    
+    return R * c
+
+
+def calculate_bearing(point1: List[float], point2: List[float]) -> float:
+    """
+    Calculate the bearing between two points.
+    
+    Args:
+        point1: [latitude, longitude]
+        point2: [latitude, longitude]
+    
+    Returns:
+        Bearing in degrees (0-360)
+    """
+    lat1, lon1 = math.radians(point1[0]), math.radians(point1[1])
+    lat2, lon2 = math.radians(point2[0]), math.radians(point2[1])
+    
+    dlon = lon2 - lon1
+    
+    x = math.sin(dlon) * math.cos(lat2)
+    y = math.cos(lat1) * math.sin(lat2) - math.sin(lat1) * math.cos(lat2) * math.cos(dlon)
+    
+    bearing = math.atan2(x, y)
+    bearing = math.degrees(bearing)
+    bearing = (bearing + 360) % 360
+    
+    return bearing
+
+
+def interpolate_path(path: List[List[float]], num_points: int = 100) -> List[List[float]]:
+    """
+    Interpolate a path to have more points for smoother simulation.
+    
+    Args:
+        path: List of [lat, lng] coordinates
+        num_points: Number of points in the interpolated path
+    
+    Returns:
+        Interpolated path
+    """
+    if len(path) < 2:
+        return path
+    
+    path_array = np.array(path)
+    
+    # Calculate cumulative distances
+    distances = [0]
+    for i in range(1, len(path)):
+        d = calculate_distance(path[i-1], path[i])
+        distances.append(distances[-1] + d)
+    
+    total_distance = distances[-1]
+    if total_distance == 0:
+        return path
+    
+    # Interpolate
+    target_distances = np.linspace(0, total_distance, num_points)
+    interpolated = []
+    
+    for target in target_distances:
+        # Find the segment
+        for i in range(len(distances) - 1):
+            if distances[i] <= target <= distances[i+1]:
+                if distances[i+1] - distances[i] == 0:
+                    t = 0
+                else:
+                    t = (target - distances[i]) / (distances[i+1] - distances[i])
+                
+                lat = path[i][0] + t * (path[i+1][0] - path[i][0])
+                lng = path[i][1] + t * (path[i+1][1] - path[i][1])
+                interpolated.append([lat, lng])
+                break
+    
+    return interpolated
+
+
+def estimate_speed_at_point(
+    path: List[List[float]],
+    initial_speed: float,
+    point_index: int,
+    is_braking: bool = False,
+    is_accelerating: bool = False
+) -> float:
+    """
+    Estimate speed at a specific point along the path.
+    
+    Args:
+        path: Vehicle path
+        initial_speed: Initial speed in km/h
+        point_index: Index of the point
+        is_braking: Whether vehicle is braking
+        is_accelerating: Whether vehicle is accelerating
+    
+    Returns:
+        Estimated speed at the point in km/h
+    """
+    if not path or point_index >= len(path):
+        return initial_speed
+    
+    progress = point_index / len(path)
+    
+    if is_braking:
+        # Assume linear deceleration
+        return initial_speed * (1 - progress * 0.5)
+    elif is_accelerating:
+        # Assume slight acceleration
+        return initial_speed * (1 + progress * 0.2)
+    else:
+        return initial_speed
+
+
+def find_intersection_point(
+    path1: List[List[float]],
+    path2: List[List[float]]
+) -> Tuple[List[float], int, int]:
+    """
+    Find the intersection point between two paths.
+    
+    Args:
+        path1: First vehicle path
+        path2: Second vehicle path
+    
+    Returns:
+        Tuple of (intersection point, index in path1, index in path2)
+    """
+    if not path1 or not path2:
+        return None, -1, -1
+    
+    min_distance = float('inf')
+    intersection = None
+    idx1, idx2 = -1, -1
+    
+    for i, p1 in enumerate(path1):
+        for j, p2 in enumerate(path2):
+            dist = calculate_distance(p1, p2)
+            if dist < min_distance:
+                min_distance = dist
+                intersection = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2]
+                idx1, idx2 = i, j
+    
+    # Only consider as intersection if distance is small enough
+    if min_distance < 50:  # 50 meters threshold
+        return intersection, idx1, idx2
+    
+    return None, -1, -1
+
+
+def calculate_impact_angle(
+    direction1: str,
+    direction2: str
+) -> float:
+    """
+    Calculate the angle of impact between two vehicles.
+    
+    Args:
+        direction1: Direction of vehicle 1
+        direction2: Direction of vehicle 2
+    
+    Returns:
+        Impact angle in degrees
+    """
+    direction_angles = {
+        'north': 0, 'northeast': 45, 'east': 90, 'southeast': 135,
+        'south': 180, 'southwest': 225, 'west': 270, 'northwest': 315
+    }
+    
+    angle1 = direction_angles.get(direction1, 0)
+    angle2 = direction_angles.get(direction2, 90)
+    
+    diff = abs(angle1 - angle2)
+    if diff > 180:
+        diff = 360 - diff
+    
+    return diff
+
+
+def estimate_stopping_distance(speed_kmh: float, road_condition: str = 'dry') -> float:
+    """
+    Estimate the stopping distance for a vehicle.
+    
+    Args:
+        speed_kmh: Speed in km/h
+        road_condition: 'dry', 'wet', 'sandy', 'oily'
+    
+    Returns:
+        Stopping distance in meters
+    """
+    speed_ms = speed_kmh / 3.6
+    
+    # Friction coefficients
+    friction = {
+        'dry': 0.8,
+        'wet': 0.5,
+        'sandy': 0.4,
+        'oily': 0.25
+    }
+    
+    mu = friction.get(road_condition, 0.8)
+    g = 9.81  # Gravity
+    
+    # Stopping distance = v² / (2 * μ * g)
+    stopping_distance = (speed_ms ** 2) / (2 * mu * g)
+    
+    # Add reaction distance (assuming 1.5 second reaction time)
+    reaction_distance = speed_ms * 1.5
+    
+    return stopping_distance + reaction_distance
+
+
+def format_duration(seconds: float) -> str:
+    """Format duration in seconds to human-readable string."""
+    if seconds < 1:
+        return f"{seconds*1000:.0f} ms"
+    elif seconds < 60:
+        return f"{seconds:.1f} s"
+    else:
+        minutes = int(seconds // 60)
+        secs = seconds % 60
+        return f"{minutes} min {secs:.0f} s"
+
+
+def format_speed(speed_kmh: float) -> str:
+    """Format speed to human-readable string."""
+    return f"{speed_kmh:.0f} km/h"
+
+
+def format_distance(meters: float) -> str:
+    """Format distance to human-readable string."""
+    if meters < 1000:
+        return f"{meters:.1f} m"
+    else:
+        return f"{meters/1000:.2f} km"
+
+
+def validate_coordinates(lat: float, lng: float) -> bool:
+    """Validate geographic coordinates."""
+    return -90 <= lat <= 90 and -180 <= lng <= 180
+
+
+def validate_speed(speed: float) -> bool:
+    """Validate vehicle speed."""
+    return 0 <= speed <= 300  # Max 300 km/h
+
+
+def generate_unique_id() -> str:
+    """Generate a unique identifier."""
+    import uuid
+    return str(uuid.uuid4())[:8]
+
+
+def get_timestamp() -> str:
+    """Get current timestamp string."""
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

map_viewer.py

@@ -0,0 +1,435 @@
+"""
+Map Viewer Component
+====================
+Handles map display and vehicle path drawing using Folium.
+"""
+
+import streamlit as st
+import folium
+from streamlit_folium import st_folium, folium_static
+from folium.plugins import Draw
+import json
+from typing import List
+
+from config import CASE_STUDY_LOCATION, MAP_CONFIG, COLORS
+
+
+def create_base_map(location: dict = None) -> folium.Map:
+    """
+    Create a base Folium map centered on the accident location.
+    
+    Args:
+        location: Dictionary with latitude, longitude, and name
+    
+    Returns:
+        Folium Map object
+    """
+    if location is None:
+        location = CASE_STUDY_LOCATION
+    
+    # Create map
+    m = folium.Map(
+        location=[location['latitude'], location['longitude']],
+        zoom_start=MAP_CONFIG['default_zoom'],
+        tiles='OpenStreetMap'
+    )
+    
+    # Add location marker
+    folium.Marker(
+        location=[location['latitude'], location['longitude']],
+        popup=location.get('name', 'Accident Location'),
+        icon=folium.Icon(color='red', icon='info-sign'),
+        tooltip="Accident Location"
+    ).add_to(m)
+    
+    # Add circle to show area of interest
+    folium.Circle(
+        location=[location['latitude'], location['longitude']],
+        radius=location.get('radius_meters', 200),
+        color='blue',
+        fill=True,
+        fill_opacity=0.1,
+        popup="Analysis Area"
+    ).add_to(m)
+    
+    return m
+
+
+def add_draw_control(m: folium.Map) -> folium.Map:
+    """
+    Add drawing controls to the map for path definition.
+    
+    Args:
+        m: Folium Map object
+    
+    Returns:
+        Folium Map with draw controls
+    """
+    draw = Draw(
+        draw_options={
+            'polyline': {
+                'allowIntersection': True,
+                'shapeOptions': {
+                    'color': '#FF4B4B',
+                    'weight': 4
+                }
+            },
+            'polygon': False,
+            'circle': False,
+            'rectangle': False,
+            'circlemarker': False,
+            'marker': True
+        },
+        edit_options={'edit': True, 'remove': True}
+    )
+    draw.add_to(m)
+    
+    return m
+
+
+def add_vehicle_path(m: folium.Map, path: list, vehicle_id: int) -> folium.Map:
+    """
+    Add a vehicle path to the map.
+    
+    Args:
+        m: Folium Map object
+        path: List of [lat, lng] coordinates
+        vehicle_id: 1 or 2 to determine color
+    
+    Returns:
+        Folium Map with vehicle path
+    """
+    if not path or len(path) < 2:
+        return m
+    
+    color = COLORS['vehicle_1'] if vehicle_id == 1 else COLORS['vehicle_2']
+    
+    # Add the path line
+    folium.PolyLine(
+        locations=path,
+        color=color,
+        weight=4,
+        opacity=0.8,
+        popup=f"Vehicle {vehicle_id} Path",
+        tooltip=f"Vehicle {vehicle_id}"
+    ).add_to(m)
+    
+    # Add start marker
+    folium.Marker(
+        location=path[0],
+        popup=f"Vehicle {vehicle_id} Start",
+        icon=folium.Icon(
+            color='green' if vehicle_id == 1 else 'blue',
+            icon='play'
+        )
+    ).add_to(m)
+    
+    # Add end marker
+    folium.Marker(
+        location=path[-1],
+        popup=f"Vehicle {vehicle_id} End",
+        icon=folium.Icon(
+            color='red' if vehicle_id == 1 else 'darkblue',
+            icon='stop'
+        )
+    ).add_to(m)
+    
+    # Add direction arrows
+    for i in range(len(path) - 1):
+        mid_lat = (path[i][0] + path[i+1][0]) / 2
+        mid_lng = (path[i][1] + path[i+1][1]) / 2
+        
+        folium.RegularPolygonMarker(
+            location=[mid_lat, mid_lng],
+            number_of_sides=3,
+            radius=8,
+            color=color,
+            fill=True,
+            fill_color=color,
+            fill_opacity=0.7
+        ).add_to(m)
+    
+    return m
+
+
+def add_collision_point(m: folium.Map, collision_point: list) -> folium.Map:
+    """
+    Add a collision point marker to the map.
+    
+    Args:
+        m: Folium Map object
+        collision_point: [lat, lng] of collision
+    
+    Returns:
+        Folium Map with collision marker
+    """
+    if not collision_point:
+        return m
+    
+    folium.Marker(
+        location=collision_point,
+        popup="Estimated Collision Point",
+        icon=folium.Icon(color='orange', icon='warning-sign'),
+        tooltip="💥 Collision Point"
+    ).add_to(m)
+    
+    # Add impact radius
+    folium.Circle(
+        location=collision_point,
+        radius=10,
+        color=COLORS['collision_point'],
+        fill=True,
+        fill_opacity=0.5,
+        popup="Impact Zone"
+    ).add_to(m)
+    
+    return m
+
+
+def render_map_section(vehicle_id: int = None):
+    """
+    Render the map section in Streamlit.
+    
+    Args:
+        vehicle_id: If provided, enables path drawing for that vehicle
+    """
+    location = st.session_state.accident_info['location']
+    
+    # Create base map
+    m = create_base_map(location)
+    
+    # Add existing vehicle paths
+    if st.session_state.vehicle_1.get('path'):
+        m = add_vehicle_path(m, st.session_state.vehicle_1['path'], 1)
+    
+    if st.session_state.vehicle_2.get('path'):
+        m = add_vehicle_path(m, st.session_state.vehicle_2['path'], 2)
+    
+    # Add draw controls if editing a specific vehicle
+    if vehicle_id:
+        m = add_draw_control(m)
+        
+        st.info(f"🖊️ Draw the path for Vehicle {vehicle_id} on the map. Click points to create a path, then click 'Finish' to complete.")
+    
+    # Render map and get drawing data
+    map_data = st_folium(
+        m,
+        width=700,
+        height=500,
+        returned_objects=["last_active_drawing", "all_drawings"]
+    )
+    
+    # Process drawn paths
+    if vehicle_id and map_data and map_data.get('last_active_drawing'):
+        drawing = map_data['last_active_drawing']
+        
+        if drawing.get('geometry', {}).get('type') == 'LineString':
+            coords = drawing['geometry']['coordinates']
+            # Convert from [lng, lat] to [lat, lng]
+            path = [[c[1], c[0]] for c in coords]
+            
+            if vehicle_id == 1:
+                st.session_state.vehicle_1['path'] = path
+            else:
+                st.session_state.vehicle_2['path'] = path
+            
+            st.success(f"✅ Path saved for Vehicle {vehicle_id}!")
+    
+    # Show path info and preset options
+    if vehicle_id:
+        vehicle_key = f'vehicle_{vehicle_id}'
+        current_path = st.session_state[vehicle_key].get('path', [])
+        
+        if current_path:
+            st.success(f"**✅ Path defined:** {len(current_path)} points")
+        else:
+            st.warning("⚠️ No path drawn yet. Use the drawing tools on the map OR select a preset path below.")
+        
+        # Preset path options for roundabout
+        st.markdown("---")
+        st.markdown("**🛣️ Quick Path Selection (Roundabout)**")
+        
+        preset_col1, preset_col2 = st.columns(2)
+        
+        with preset_col1:
+            entry_direction = st.selectbox(
+                f"Entry Direction (V{vehicle_id})",
+                options=['north', 'south', 'east', 'west'],
+                key=f"entry_dir_{vehicle_id}"
+            )
+        
+        with preset_col2:
+            exit_direction = st.selectbox(
+                f"Exit Direction (V{vehicle_id})",
+                options=['north', 'south', 'east', 'west'],
+                index=2 if entry_direction == 'north' else 0,
+                key=f"exit_dir_{vehicle_id}"
+            )
+        
+        if st.button(f"🔄 Generate Path for Vehicle {vehicle_id}", key=f"gen_path_{vehicle_id}"):
+            generated_path = generate_roundabout_path(
+                location['latitude'],
+                location['longitude'],
+                entry_direction,
+                exit_direction
+            )
+            
+            if vehicle_id == 1:
+                st.session_state.vehicle_1['path'] = generated_path
+            else:
+                st.session_state.vehicle_2['path'] = generated_path
+            
+            st.success(f"✅ Path generated: {entry_direction.title()} → {exit_direction.title()}")
+            st.rerun()
+        
+        # Manual path input as fallback
+        with st.expander("📝 Or enter path manually"):
+            st.write("Enter coordinates as: lat1,lng1;lat2,lng2;...")
+            manual_path = st.text_input(
+                "Path coordinates",
+                key=f"manual_path_{vehicle_id}",
+                placeholder="26.2397,50.5369;26.2400,50.5372"
+            )
+            
+            if st.button(f"Set Manual Path", key=f"set_path_{vehicle_id}"):
+                if manual_path:
+                    try:
+                        path = []
+                        for point in manual_path.split(';'):
+                            lat, lng = point.strip().split(',')
+                            path.append([float(lat), float(lng)])
+                        
+                        if vehicle_id == 1:
+                            st.session_state.vehicle_1['path'] = path
+                        else:
+                            st.session_state.vehicle_2['path'] = path
+                        
+                        st.success(f"Path set with {len(path)} points!")
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"Invalid format: {e}")
+
+
+def generate_roundabout_path(
+    center_lat: float,
+    center_lng: float,
+    entry_direction: str,
+    exit_direction: str
+) -> List[List[float]]:
+    """
+    Generate a realistic path through a roundabout.
+    
+    Args:
+        center_lat: Center latitude of roundabout
+        center_lng: Center longitude of roundabout
+        entry_direction: Direction vehicle enters from
+        exit_direction: Direction vehicle exits to
+    
+    Returns:
+        List of [lat, lng] coordinates forming the path
+    """
+    import math
+    
+    # Roundabout parameters
+    approach_distance = 0.0015  # ~150 meters
+    roundabout_radius = 0.0004  # ~40 meters
+    
+    # Direction to angle mapping (0 = North, clockwise)
+    dir_to_angle = {
+        'north': 90,    # Top
+        'east': 0,      # Right
+        'south': 270,   # Bottom
+        'west': 180     # Left
+    }
+    
+    entry_angle = math.radians(dir_to_angle[entry_direction])
+    exit_angle = math.radians(dir_to_angle[exit_direction])
+    
+    path = []
+    
+    # Entry point (outside roundabout)
+    entry_lat = center_lat + approach_distance * math.sin(entry_angle)
+    entry_lng = center_lng + approach_distance * math.cos(entry_angle)
+    path.append([entry_lat, entry_lng])
+    
+    # Entry to roundabout edge
+    edge_lat = center_lat + roundabout_radius * 1.5 * math.sin(entry_angle)
+    edge_lng = center_lng + roundabout_radius * 1.5 * math.cos(entry_angle)
+    path.append([edge_lat, edge_lng])
+    
+    # Points along the roundabout (clockwise)
+    entry_deg = dir_to_angle[entry_direction]
+    exit_deg = dir_to_angle[exit_direction]
+    
+    # Calculate arc (always go clockwise in roundabout)
+    if exit_deg <= entry_deg:
+        exit_deg += 360
+    
+    # Add intermediate points along the arc
+    num_arc_points = max(2, (exit_deg - entry_deg) // 45)
+    for i in range(1, num_arc_points + 1):
+        angle = entry_deg + (exit_deg - entry_deg) * i / (num_arc_points + 1)
+        angle_rad = math.radians(angle)
+        arc_lat = center_lat + roundabout_radius * math.sin(angle_rad)
+        arc_lng = center_lng + roundabout_radius * math.cos(angle_rad)
+        path.append([arc_lat, arc_lng])
+    
+    # Exit from roundabout edge
+    exit_edge_lat = center_lat + roundabout_radius * 1.5 * math.sin(exit_angle)
+    exit_edge_lng = center_lng + roundabout_radius * 1.5 * math.cos(exit_angle)
+    path.append([exit_edge_lat, exit_edge_lng])
+    
+    # Exit point (outside roundabout)
+    exit_lat = center_lat + approach_distance * math.sin(exit_angle)
+    exit_lng = center_lng + approach_distance * math.cos(exit_angle)
+    path.append([exit_lat, exit_lng])
+    
+    return path
+
+
+def render_results_map(scenarios: list, selected_scenario: int = 0):
+    """
+    Render a map showing analysis results for a specific scenario.
+    
+    Args:
+        scenarios: List of generated scenarios
+        selected_scenario: Index of selected scenario
+    """
+    if not scenarios:
+        st.warning("No scenarios to display")
+        return
+    
+    scenario = scenarios[selected_scenario]
+    location = st.session_state.accident_info['location']
+    
+    # Create map
+    m = create_base_map(location)
+    
+    # Add vehicle paths
+    if scenario.get('vehicle_1_path'):
+        m = add_vehicle_path(m, scenario['vehicle_1_path'], 1)
+    
+    if scenario.get('vehicle_2_path'):
+        m = add_vehicle_path(m, scenario['vehicle_2_path'], 2)
+    
+    # Add collision point
+    if scenario.get('collision_point'):
+        m = add_collision_point(m, scenario['collision_point'])
+    
+    # Add scenario info popup
+    info_html = f"""
+    <div style="width: 200px;">
+        <h4>Scenario {selected_scenario + 1}</h4>
+        <p><b>Probability:</b> {scenario.get('probability', 0)*100:.1f}%</p>
+        <p><b>Type:</b> {scenario.get('accident_type', 'Unknown')}</p>
+    </div>
+    """
+    
+    folium.Marker(
+        location=[location['latitude'], location['longitude']],
+        popup=folium.Popup(info_html, max_width=250),
+        icon=folium.Icon(color='purple', icon='info-sign')
+    ).add_to(m)
+    
+    # Display map
+    folium_static(m, width=700, height=500)

model_metadata.json

@@ -0,0 +1,22 @@
+{
+  "framework": "MindSpore",
+  "version": "2.7.0",
+  "input_dim": 31,
+  "num_classes": 7,
+  "architecture": "31\u2192128\u219264\u219232\u21927",
+  "test_accuracy": 0.9238333333333333,
+  "best_train_accuracy": 0.9269166666666667,
+  "epochs_trained": 100,
+  "batch_size": 64,
+  "learning_rate": 0.001,
+  "accident_classes": {
+    "rear_end_collision": 0,
+    "side_impact": 1,
+    "head_on_collision": 2,
+    "sideswipe": 3,
+    "roundabout_entry_collision": 4,
+    "lane_change_collision": 5,
+    "intersection_collision": 6
+  },
+  "feature_count": 31
+}

party_input.py

@@ -0,0 +1,243 @@
+"""
+Party/Driver Input Component
+============================
+Handles detailed party (driver) information input forms.
+"""
+
+import streamlit as st
+from typing import Dict, Any
+
+
+def init_party_data() -> Dict[str, Any]:
+    """Initialize empty party data structure."""
+    return {
+        'full_name': '',
+        'id_iqama': '',
+        'phone': '',
+        'role': 'Driver',
+        'vehicle_make_model': '',
+        'plate_number': '',
+        'insurance': '',
+        'damage_notes': '',
+        'statement': ''
+    }
+
+
+def render_party_input(party_num: int) -> Dict[str, Any]:
+    """
+    Render the party/driver input form.
+    
+    Args:
+        party_num: 1 or 2 to determine which party
+    
+    Returns:
+        Dictionary containing party data
+    """
+    party_key = f'party_{party_num}'
+    
+    # Initialize party data in session state if not exists
+    if party_key not in st.session_state:
+        st.session_state[party_key] = init_party_data()
+    
+    color = "#FF4B4B" if party_num == 1 else "#4B7BFF"
+    
+    st.markdown(f"""
+    <div style="
+        background: linear-gradient(135deg, {'#1a1a2e' if party_num == 1 else '#1a1a2e'} 0%, #16213e 100%);
+        border: 1px solid {color};
+        border-radius: 10px;
+        padding: 1.5rem;
+        margin-bottom: 1rem;
+    ">
+        <h3 style="color: {color}; margin: 0 0 1rem 0;">
+            {'👤' if party_num == 1 else '👤'} Party {party_num} Information
+        </h3>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Full Name
+    full_name = st.text_input(
+        f"Full Name (Party {party_num})",
+        value=st.session_state[party_key].get('full_name', ''),
+        placeholder="Enter full name",
+        key=f"name_{party_num}"
+    )
+    st.session_state[party_key]['full_name'] = full_name
+    
+    # ID / Iqama
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        id_iqama = st.text_input(
+            f"ID / Iqama (Party {party_num})",
+            value=st.session_state[party_key].get('id_iqama', ''),
+            placeholder="ID or Iqama number",
+            key=f"id_{party_num}"
+        )
+        st.session_state[party_key]['id_iqama'] = id_iqama
+    
+    with col2:
+        phone = st.text_input(
+            f"Phone (Party {party_num})",
+            value=st.session_state[party_key].get('phone', ''),
+            placeholder="+973 XXXX XXXX",
+            key=f"phone_{party_num}"
+        )
+        st.session_state[party_key]['phone'] = phone
+    
+    # Role
+    role = st.selectbox(
+        f"Role (Party {party_num})",
+        options=['Driver', 'Passenger', 'Pedestrian', 'Cyclist', 'Witness'],
+        index=['Driver', 'Passenger', 'Pedestrian', 'Cyclist', 'Witness'].index(
+            st.session_state[party_key].get('role', 'Driver')
+        ),
+        key=f"role_{party_num}"
+    )
+    st.session_state[party_key]['role'] = role
+    
+    st.markdown("---")
+    st.markdown(f"**🚗 Vehicle Information (Party {party_num})**")
+    
+    # Vehicle Make/Model
+    vehicle = st.text_input(
+        f"Vehicle (Party {party_num})",
+        value=st.session_state[party_key].get('vehicle_make_model', ''),
+        placeholder="e.g., Toyota Camry 2022",
+        key=f"vehicle_{party_num}"
+    )
+    st.session_state[party_key]['vehicle_make_model'] = vehicle
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Plate Number
+        plate = st.text_input(
+            f"Plate Number (Party {party_num})",
+            value=st.session_state[party_key].get('plate_number', ''),
+            placeholder="e.g., 12345",
+            key=f"plate_{party_num}"
+        )
+        st.session_state[party_key]['plate_number'] = plate
+    
+    with col2:
+        # Insurance
+        insurance = st.text_input(
+            f"Insurance (Party {party_num})",
+            value=st.session_state[party_key].get('insurance', ''),
+            placeholder="Company / Policy #",
+            key=f"insurance_{party_num}"
+        )
+        st.session_state[party_key]['insurance'] = insurance
+    
+    st.markdown("---")
+    st.markdown(f"**📝 Damage & Statement (Party {party_num})**")
+    
+    # Damage Notes
+    damage = st.text_area(
+        f"Damage Notes (Party {party_num})",
+        value=st.session_state[party_key].get('damage_notes', ''),
+        placeholder="e.g., front bumper, right door, headlight...",
+        height=80,
+        key=f"damage_{party_num}"
+    )
+    st.session_state[party_key]['damage_notes'] = damage
+    
+    # Statement
+    statement = st.text_area(
+        f"Statement (Party {party_num})",
+        value=st.session_state[party_key].get('statement', ''),
+        placeholder=f"What party {party_num} says happened...",
+        height=100,
+        key=f"statement_{party_num}"
+    )
+    st.session_state[party_key]['statement'] = statement
+    
+    return st.session_state[party_key]
+
+
+def render_party_summary(party_num: int):
+    """Render a compact summary of party data."""
+    party_key = f'party_{party_num}'
+    
+    if party_key not in st.session_state:
+        st.warning(f"No data for Party {party_num}")
+        return
+    
+    party = st.session_state[party_key]
+    color = "#FF4B4B" if party_num == 1 else "#4B7BFF"
+    
+    name = party.get('full_name', 'Not provided') or 'Not provided'
+    vehicle = party.get('vehicle_make_model', 'Not specified') or 'Not specified'
+    plate = party.get('plate_number', 'N/A') or 'N/A'
+    
+    st.markdown(f"""
+    <div style="
+        background: #1a1a2e;
+        border-left: 4px solid {color};
+        border-radius: 5px;
+        padding: 1rem;
+        margin: 0.5rem 0;
+    ">
+        <h4 style="color: {color}; margin: 0 0 0.5rem 0;">Party {party_num}</h4>
+        <p style="margin: 0.2rem 0; color: #ccc;"><b>Name:</b> {name}</p>
+        <p style="margin: 0.2rem 0; color: #ccc;"><b>Vehicle:</b> {vehicle}</p>
+        <p style="margin: 0.2rem 0; color: #ccc;"><b>Plate:</b> {plate}</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def render_evidence_upload():
+    """Render the evidence photo upload section."""
+    
+    st.markdown("""
+    <div style="
+        background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+        border: 1px solid #ffc107;
+        border-radius: 10px;
+        padding: 1.5rem;
+        margin: 1rem 0;
+    ">
+        <h3 style="color: #ffc107; margin: 0 0 0.5rem 0;">
+            📷 Evidence (Optional)
+        </h3>
+        <p style="color: #aaa; margin: 0;">Upload photos of the accident scene, vehicle damage, etc.</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # File uploader
+    uploaded_files = st.file_uploader(
+        "Upload photos (optional)",
+        type=['png', 'jpg', 'jpeg'],
+        accept_multiple_files=True,
+        key="evidence_photos",
+        help="Upload accident scene photos, vehicle damage photos, etc."
+    )
+    
+    if uploaded_files:
+        st.success(f"✅ {len(uploaded_files)} photo(s) uploaded")
+        
+        # Display thumbnails
+        cols = st.columns(min(len(uploaded_files), 4))
+        for i, file in enumerate(uploaded_files[:4]):
+            with cols[i % 4]:
+                st.image(file, caption=file.name, use_container_width=True)
+        
+        # Store in session state
+        st.session_state['evidence_photos'] = uploaded_files
+    else:
+        st.info("💡 Tip: Photos can help with accident reconstruction analysis")
+    
+    return uploaded_files
+
+
+def render_compact_party_inputs():
+    """Render both party inputs in a compact two-column layout."""
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        render_party_input(1)
+    
+    with col2:
+        render_party_input(2)

report_generator.py

@@ -0,0 +1,734 @@
+"""
+Report Generator
+================
+Generates PDF and HTML reports for accident analysis.
+"""
+
+import os
+from datetime import datetime
+from typing import Dict, List, Any
+from pathlib import Path
+
+from config import REPORTS_DIR, REPORT_CONFIG, VEHICLE_TYPES
+
+
+def generate_report(
+    results: Dict[str, Any],
+    scenarios: List[Dict[str, Any]],
+    accident_info: Dict[str, Any],
+    vehicle_1: Dict[str, Any],
+    vehicle_2: Dict[str, Any],
+    format: str = 'pdf',
+    include_maps: bool = True,
+    include_charts: bool = True,
+    include_raw_data: bool = False
+) -> str:
+    """
+    Generate a comprehensive accident analysis report.
+    
+    Args:
+        results: Analysis results dictionary
+        scenarios: List of generated scenarios
+        accident_info: Accident context information
+        vehicle_1: First vehicle data
+        vehicle_2: Second vehicle data
+        format: Output format ('pdf' or 'html')
+        include_maps: Whether to include map visualizations
+        include_charts: Whether to include charts
+        include_raw_data: Whether to include raw data tables
+    
+    Returns:
+        Path to generated report file
+    """
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    if format.lower() == 'html':
+        return generate_html_report(
+            results, scenarios, accident_info, vehicle_1, vehicle_2,
+            timestamp, include_maps, include_charts, include_raw_data
+        )
+    else:
+        return generate_pdf_report(
+            results, scenarios, accident_info, vehicle_1, vehicle_2,
+            timestamp, include_maps, include_charts, include_raw_data
+        )
+
+
+def generate_html_report(
+    results: Dict[str, Any],
+    scenarios: List[Dict[str, Any]],
+    accident_info: Dict[str, Any],
+    vehicle_1: Dict[str, Any],
+    vehicle_2: Dict[str, Any],
+    timestamp: str,
+    include_maps: bool,
+    include_charts: bool,
+    include_raw_data: bool
+) -> str:
+    """Generate HTML report."""
+    
+    # Get most likely scenario
+    most_likely = results.get('most_likely_scenario', {})
+    fault = results.get('preliminary_fault_assessment', {})
+    
+    v1_type = VEHICLE_TYPES.get(vehicle_1.get('type', 'sedan'), {}).get('name', 'Sedan')
+    v2_type = VEHICLE_TYPES.get(vehicle_2.get('type', 'sedan'), {}).get('name', 'Sedan')
+    
+    html_content = f"""
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Traffic Accident Analysis Report</title>
+    <style>
+        * {{
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }}
+        
+        body {{
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            line-height: 1.6;
+            color: #333;
+            background: #f5f5f5;
+        }}
+        
+        .container {{
+            max-width: 1000px;
+            margin: 0 auto;
+            background: white;
+            box-shadow: 0 0 20px rgba(0,0,0,0.1);
+        }}
+        
+        .header {{
+            background: linear-gradient(135deg, #1e3a5f 0%, #2d5a87 100%);
+            color: white;
+            padding: 40px;
+            text-align: center;
+        }}
+        
+        .header h1 {{
+            font-size: 2.5rem;
+            margin-bottom: 10px;
+        }}
+        
+        .header .subtitle {{
+            opacity: 0.9;
+            font-size: 1.1rem;
+        }}
+        
+        .section {{
+            padding: 30px 40px;
+            border-bottom: 1px solid #eee;
+        }}
+        
+        .section h2 {{
+            color: #1e3a5f;
+            margin-bottom: 20px;
+            padding-bottom: 10px;
+            border-bottom: 2px solid #2d5a87;
+        }}
+        
+        .summary-grid {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin: 20px 0;
+        }}
+        
+        .summary-card {{
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 10px;
+            text-align: center;
+            border-top: 4px solid #2d5a87;
+        }}
+        
+        .summary-card .label {{
+            font-size: 0.9rem;
+            color: #666;
+            margin-bottom: 5px;
+        }}
+        
+        .summary-card .value {{
+            font-size: 1.8rem;
+            font-weight: bold;
+            color: #1e3a5f;
+        }}
+        
+        .summary-card .delta {{
+            font-size: 0.85rem;
+            margin-top: 5px;
+        }}
+        
+        .delta.high {{ color: #28a745; }}
+        .delta.medium {{ color: #ffc107; }}
+        .delta.low {{ color: #dc3545; }}
+        
+        .info-grid {{
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 30px;
+        }}
+        
+        .info-box {{
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 10px;
+        }}
+        
+        .info-box h3 {{
+            color: #1e3a5f;
+            margin-bottom: 15px;
+        }}
+        
+        .info-row {{
+            display: flex;
+            justify-content: space-between;
+            padding: 8px 0;
+            border-bottom: 1px solid #eee;
+        }}
+        
+        .info-row:last-child {{
+            border-bottom: none;
+        }}
+        
+        .vehicle-card {{
+            background: white;
+            border-radius: 10px;
+            padding: 20px;
+            margin: 15px 0;
+        }}
+        
+        .vehicle-card.v1 {{
+            border-left: 4px solid #FF4B4B;
+        }}
+        
+        .vehicle-card.v2 {{
+            border-left: 4px solid #4B7BFF;
+        }}
+        
+        .scenario-card {{
+            background: #f8f9fa;
+            border-radius: 10px;
+            padding: 20px;
+            margin: 15px 0;
+            border-left: 4px solid #2d5a87;
+        }}
+        
+        .scenario-header {{
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 15px;
+        }}
+        
+        .probability {{
+            font-size: 1.5rem;
+            font-weight: bold;
+        }}
+        
+        .probability.high {{ color: #28a745; }}
+        .probability.medium {{ color: #ffc107; }}
+        .probability.low {{ color: #dc3545; }}
+        
+        .progress-bar {{
+            background: #e9ecef;
+            border-radius: 5px;
+            height: 10px;
+            margin: 10px 0;
+            overflow: hidden;
+        }}
+        
+        .progress-fill {{
+            background: #2d5a87;
+            height: 100%;
+            border-radius: 5px;
+        }}
+        
+        .factors-list {{
+            list-style: none;
+            padding: 0;
+        }}
+        
+        .factors-list li {{
+            padding: 5px 0;
+            padding-left: 20px;
+            position: relative;
+        }}
+        
+        .factors-list li::before {{
+            content: "•";
+            color: #2d5a87;
+            position: absolute;
+            left: 0;
+        }}
+        
+        .timeline {{
+            margin: 20px 0;
+        }}
+        
+        .timeline-item {{
+            display: flex;
+            margin: 10px 0;
+        }}
+        
+        .timeline-time {{
+            min-width: 80px;
+            padding: 8px 15px;
+            background: #ffc107;
+            color: white;
+            font-weight: bold;
+            text-align: center;
+            border-radius: 5px;
+        }}
+        
+        .timeline-time.impact {{
+            background: #dc3545;
+        }}
+        
+        .timeline-time.after {{
+            background: #28a745;
+        }}
+        
+        .timeline-event {{
+            flex: 1;
+            padding: 8px 15px;
+            background: #f8f9fa;
+            margin-left: 10px;
+            border-radius: 5px;
+        }}
+        
+        .fault-assessment {{
+            background: #fff3cd;
+            padding: 20px;
+            border-radius: 10px;
+            border-left: 4px solid #ffc107;
+            margin: 20px 0;
+        }}
+        
+        .footer {{
+            background: #1e3a5f;
+            color: white;
+            padding: 30px 40px;
+            text-align: center;
+        }}
+        
+        .footer p {{
+            opacity: 0.8;
+            font-size: 0.9rem;
+        }}
+        
+        @media print {{
+            .container {{
+                box-shadow: none;
+            }}
+            
+            .section {{
+                page-break-inside: avoid;
+            }}
+        }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <!-- Header -->
+        <div class="header">
+            <h1>🚗 Traffic Accident Analysis Report</h1>
+            <p class="subtitle">AI-Powered Analysis using Huawei MindSpore</p>
+            <p style="margin-top: 15px; opacity: 0.7;">Generated: {datetime.now().strftime("%B %d, %Y at %H:%M")}</p>
+        </div>
+        
+        <!-- Executive Summary -->
+        <div class="section">
+            <h2>📊 Executive Summary</h2>
+            
+            <div class="summary-grid">
+                <div class="summary-card">
+                    <div class="label">Most Likely Scenario</div>
+                    <div class="value">#{most_likely.get('id', 1)}</div>
+                    <div class="delta high">{most_likely.get('probability', 0)*100:.1f}% probability</div>
+                </div>
+                
+                <div class="summary-card">
+                    <div class="label">Scenarios Generated</div>
+                    <div class="value">{len(scenarios)}</div>
+                    <div class="delta">AI-generated</div>
+                </div>
+                
+                <div class="summary-card">
+                    <div class="label">Collision Certainty</div>
+                    <div class="value">{results.get('overall_collision_probability', 0)*100:.1f}%</div>
+                    <div class="delta {'high' if results.get('overall_collision_probability', 0) > 0.7 else 'medium' if results.get('overall_collision_probability', 0) > 0.4 else 'low'}">
+                        {'High' if results.get('overall_collision_probability', 0) > 0.7 else 'Medium' if results.get('overall_collision_probability', 0) > 0.4 else 'Low'}
+                    </div>
+                </div>
+                
+                <div class="summary-card">
+                    <div class="label">Primary Factor</div>
+                    <div class="value" style="font-size: 1.2rem;">{fault.get('primary_factor', 'N/A').replace('_', ' ').title()[:20]}</div>
+                    <div class="delta">Vehicle {fault.get('likely_at_fault', '?')}</div>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Accident Details -->
+        <div class="section">
+            <h2>📍 Accident Details</h2>
+            
+            <div class="info-grid">
+                <div class="info-box">
+                    <h3>Location Information</h3>
+                    <div class="info-row">
+                        <span>Location:</span>
+                        <strong>{accident_info.get('location', {}).get('name', 'Unknown')}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Coordinates:</span>
+                        <strong>{accident_info.get('location', {}).get('latitude', 0):.4f}, {accident_info.get('location', {}).get('longitude', 0):.4f}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Road Type:</span>
+                        <strong>{accident_info.get('road_type', 'Unknown').replace('_', ' ').title()}</strong>
+                    </div>
+                </div>
+                
+                <div class="info-box">
+                    <h3>Conditions</h3>
+                    <div class="info-row">
+                        <span>Date/Time:</span>
+                        <strong>{accident_info.get('datetime', 'Not specified')}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Weather:</span>
+                        <strong>{accident_info.get('weather', 'Unknown').title()}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Road Condition:</span>
+                        <strong>{accident_info.get('road_condition', 'Unknown').title()}</strong>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Vehicle Information -->
+        <div class="section">
+            <h2>🚙 Vehicle Information</h2>
+            
+            <div class="info-grid">
+                <div class="vehicle-card v1">
+                    <h3 style="color: #FF4B4B;">Vehicle 1 (Red)</h3>
+                    <div class="info-row">
+                        <span>Type:</span>
+                        <strong>{v1_type}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Speed:</span>
+                        <strong>{vehicle_1.get('speed', 0)} km/h</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Direction:</span>
+                        <strong>{vehicle_1.get('direction', 'Unknown').title()}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Action:</span>
+                        <strong>{vehicle_1.get('action', 'Unknown').replace('_', ' ').title()}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Braking:</span>
+                        <strong>{'Yes' if vehicle_1.get('braking', False) else 'No'}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Signaling:</span>
+                        <strong>{'Yes' if vehicle_1.get('signaling', False) else 'No'}</strong>
+                    </div>
+                </div>
+                
+                <div class="vehicle-card v2">
+                    <h3 style="color: #4B7BFF;">Vehicle 2 (Blue)</h3>
+                    <div class="info-row">
+                        <span>Type:</span>
+                        <strong>{v2_type}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Speed:</span>
+                        <strong>{vehicle_2.get('speed', 0)} km/h</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Direction:</span>
+                        <strong>{vehicle_2.get('direction', 'Unknown').title()}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Action:</span>
+                        <strong>{vehicle_2.get('action', 'Unknown').replace('_', ' ').title()}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Braking:</span>
+                        <strong>{'Yes' if vehicle_2.get('braking', False) else 'No'}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Signaling:</span>
+                        <strong>{'Yes' if vehicle_2.get('signaling', False) else 'No'}</strong>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Generated Scenarios -->
+        <div class="section">
+            <h2>🎯 AI-Generated Scenarios</h2>
+            
+            {''.join([f'''
+            <div class="scenario-card">
+                <div class="scenario-header">
+                    <div>
+                        <h3>Scenario {i+1}: {s['accident_type'].replace('_', ' ').title()}</h3>
+                    </div>
+                    <div class="probability {'high' if s['probability'] > 0.4 else 'medium' if s['probability'] > 0.2 else 'low'}">
+                        {s['probability']*100:.1f}%
+                    </div>
+                </div>
+                
+                <p>{s['description']}</p>
+                
+                <div style="margin-top: 15px;">
+                    <strong>Analysis Metrics:</strong>
+                    <div style="margin-top: 10px;">
+                        <span>Collision Probability: {s['metrics']['collision_probability']*100:.1f}%</span>
+                        <div class="progress-bar">
+                            <div class="progress-fill" style="width: {s['metrics']['collision_probability']*100}%"></div>
+                        </div>
+                    </div>
+                    <div>
+                        <span>Path Overlap: {s['metrics']['path_overlap']*100:.1f}%</span>
+                        <div class="progress-bar">
+                            <div class="progress-fill" style="width: {s['metrics']['path_overlap']*100}%"></div>
+                        </div>
+                    </div>
+                    <p style="margin-top: 10px;">Speed Differential: {s['metrics']['speed_differential']:.1f} km/h | Time to Collision: {s['metrics']['time_to_collision']:.2f}s</p>
+                </div>
+                
+                <div style="margin-top: 15px;">
+                    <strong>Contributing Factors:</strong>
+                    <ul class="factors-list">
+                        {''.join([f"<li>{f.replace('_', ' ').title()}</li>" for f in s['contributing_factors']])}
+                    </ul>
+                </div>
+            </div>
+            ''' for i, s in enumerate(scenarios)])}
+        </div>
+        
+        <!-- Fault Assessment -->
+        <div class="section">
+            <h2>⚖️ Preliminary Fault Assessment</h2>
+            
+            <div class="fault-assessment">
+                <h3>⚠️ Disclaimer</h3>
+                <p>This is a preliminary AI-generated assessment for reference purposes only. Final fault determination should be made by qualified traffic authorities based on comprehensive investigation.</p>
+            </div>
+            
+            <div class="info-grid" style="margin-top: 20px;">
+                <div class="info-box">
+                    <h3>Contribution Analysis</h3>
+                    <div style="margin: 15px 0;">
+                        <span style="color: #FF4B4B;">Vehicle 1: {fault.get('vehicle_1_contribution', 50):.1f}%</span>
+                        <div class="progress-bar">
+                            <div class="progress-fill" style="width: {fault.get('vehicle_1_contribution', 50)}%; background: #FF4B4B;"></div>
+                        </div>
+                    </div>
+                    <div>
+                        <span style="color: #4B7BFF;">Vehicle 2: {fault.get('vehicle_2_contribution', 50):.1f}%</span>
+                        <div class="progress-bar">
+                            <div class="progress-fill" style="width: {fault.get('vehicle_2_contribution', 50)}%; background: #4B7BFF;"></div>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="info-box">
+                    <h3>Assessment Summary</h3>
+                    <div class="info-row">
+                        <span>Higher Contribution:</span>
+                        <strong>Vehicle {fault.get('likely_at_fault', '?')}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Primary Factor:</span>
+                        <strong>{fault.get('primary_factor', 'Unknown').replace('_', ' ').title()}</strong>
+                    </div>
+                    <div class="info-row">
+                        <span>Assessment Confidence:</span>
+                        <strong>{fault.get('confidence', 0)*100:.1f}%</strong>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <!-- Timeline -->
+        <div class="section">
+            <h2>⏱️ Estimated Accident Timeline</h2>
+            
+            <div class="timeline">
+                {''.join([f'''
+                <div class="timeline-item">
+                    <div class="timeline-time {'impact' if e['time'] == 0 else 'after' if e['time'] > 0 else ''}">{e['time']:+.1f}s</div>
+                    <div class="timeline-event">{e['event']}</div>
+                </div>
+                ''' for e in results.get('timeline', [])])}
+            </div>
+        </div>
+        
+        <!-- Footer -->
+        <div class="footer">
+            <p><strong>Traffic Accident Reconstruction System</strong></p>
+            <p>Huawei AI Innovation Challenge 2026</p>
+            <p style="margin-top: 10px;">Powered by Huawei MindSpore AI Framework</p>
+            <p style="margin-top: 15px; font-size: 0.8rem;">Report ID: {timestamp}</p>
+        </div>
+    </div>
+</body>
+</html>
+    """
+    
+    # Save the report
+    report_path = REPORTS_DIR / f"accident_report_{timestamp}.html"
+    
+    with open(report_path, 'w', encoding='utf-8') as f:
+        f.write(html_content)
+    
+    return str(report_path)
+
+
+def generate_pdf_report(
+    results: Dict[str, Any],
+    scenarios: List[Dict[str, Any]],
+    accident_info: Dict[str, Any],
+    vehicle_1: Dict[str, Any],
+    vehicle_2: Dict[str, Any],
+    timestamp: str,
+    include_maps: bool,
+    include_charts: bool,
+    include_raw_data: bool
+) -> str:
+    """Generate PDF report using ReportLab."""
+    
+    try:
+        from reportlab.lib import colors
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.lib.units import inch, cm
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
+        from reportlab.lib.enums import TA_CENTER, TA_LEFT
+    except ImportError:
+        # Fall back to HTML if ReportLab not available
+        return generate_html_report(
+            results, scenarios, accident_info, vehicle_1, vehicle_2,
+            timestamp, include_maps, include_charts, include_raw_data
+        )
+    
+    report_path = REPORTS_DIR / f"accident_report_{timestamp}.pdf"
+    
+    doc = SimpleDocTemplate(
+        str(report_path),
+        pagesize=A4,
+        rightMargin=72,
+        leftMargin=72,
+        topMargin=72,
+        bottomMargin=72
+    )
+    
+    styles = getSampleStyleSheet()
+    
+    # Custom styles
+    title_style = ParagraphStyle(
+        'CustomTitle',
+        parent=styles['Heading1'],
+        fontSize=24,
+        spaceAfter=30,
+        alignment=TA_CENTER,
+        textColor=colors.HexColor('#1e3a5f')
+    )
+    
+    heading_style = ParagraphStyle(
+        'CustomHeading',
+        parent=styles['Heading2'],
+        fontSize=16,
+        spaceBefore=20,
+        spaceAfter=10,
+        textColor=colors.HexColor('#2d5a87')
+    )
+    
+    story = []
+    
+    # Title
+    story.append(Paragraph("Traffic Accident Analysis Report", title_style))
+    story.append(Paragraph("AI-Powered Analysis using Huawei MindSpore", styles['Normal']))
+    story.append(Spacer(1, 30))
+    
+    # Executive Summary
+    story.append(Paragraph("Executive Summary", heading_style))
+    
+    most_likely = results.get('most_likely_scenario', {})
+    fault = results.get('preliminary_fault_assessment', {})
+    
+    summary_data = [
+        ['Most Likely Scenario', f"#{most_likely.get('id', 1)} ({most_likely.get('probability', 0)*100:.1f}%)"],
+        ['Scenarios Generated', str(len(scenarios))],
+        ['Collision Certainty', f"{results.get('overall_collision_probability', 0)*100:.1f}%"],
+        ['Primary Factor', fault.get('primary_factor', 'N/A').replace('_', ' ').title()]
+    ]
+    
+    summary_table = Table(summary_data, colWidths=[3*inch, 3*inch])
+    summary_table.setStyle(TableStyle([
+        ('BACKGROUND', (0, 0), (0, -1), colors.HexColor('#f8f9fa')),
+        ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
+        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+        ('FONTNAME', (0, 0), (-1, -1), 'Helvetica'),
+        ('FONTSIZE', (0, 0), (-1, -1), 10),
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 12),
+        ('TOPPADDING', (0, 0), (-1, -1), 12),
+        ('GRID', (0, 0), (-1, -1), 1, colors.HexColor('#dee2e6'))
+    ]))
+    
+    story.append(summary_table)
+    story.append(Spacer(1, 20))
+    
+    # Location Details
+    story.append(Paragraph("Accident Details", heading_style))
+    
+    location_data = [
+        ['Location', accident_info.get('location', {}).get('name', 'Unknown')],
+        ['Road Type', accident_info.get('road_type', 'Unknown').replace('_', ' ').title()],
+        ['Weather', accident_info.get('weather', 'Unknown').title()],
+        ['Road Condition', accident_info.get('road_condition', 'Unknown').title()]
+    ]
+    
+    location_table = Table(location_data, colWidths=[2*inch, 4*inch])
+    location_table.setStyle(TableStyle([
+        ('BACKGROUND', (0, 0), (0, -1), colors.HexColor('#f8f9fa')),
+        ('GRID', (0, 0), (-1, -1), 1, colors.HexColor('#dee2e6')),
+        ('FONTNAME', (0, 0), (-1, -1), 'Helvetica'),
+        ('FONTSIZE', (0, 0), (-1, -1), 10),
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 8),
+        ('TOPPADDING', (0, 0), (-1, -1), 8),
+    ]))
+    
+    story.append(location_table)
+    story.append(Spacer(1, 20))
+    
+    # Scenarios
+    story.append(Paragraph("Generated Scenarios", heading_style))
+    
+    for i, scenario in enumerate(scenarios):
+        story.append(Paragraph(
+            f"<b>Scenario {i+1}: {scenario['accident_type'].replace('_', ' ').title()}</b> - {scenario['probability']*100:.1f}% probability",
+            styles['Normal']
+        ))
+        story.append(Paragraph(scenario['description'], styles['Normal']))
+        story.append(Spacer(1, 10))
+    
+    # Build PDF
+    doc.build(story)
+    
+    return str(report_path)

results_display.py

@@ -0,0 +1,552 @@
+"""
+Results Display Component
+=========================
+Handles visualization of analysis results and scenarios.
+"""
+
+import streamlit as st
+import plotly.express as px
+import plotly.graph_objects as go
+import pandas as pd
+from datetime import datetime
+
+from config import COLORS, PROBABILITY_THRESHOLDS
+from ui.map_viewer import render_results_map
+
+
+def render_results():
+    """Render the complete results section."""
+    
+    results = st.session_state.analysis_results
+    scenarios = st.session_state.scenarios
+    
+    if not results or not scenarios:
+        st.warning("No results available.")
+        return
+    
+    # Summary metrics
+    render_summary_metrics(results)
+    
+    st.markdown("---")
+    
+    # Scenario tabs
+    render_scenario_tabs(scenarios)
+    
+    st.markdown("---")
+    
+    # Detailed analysis
+    render_detailed_analysis(results)
+    
+    st.markdown("---")
+    
+    # Report generation
+    render_report_section(results, scenarios)
+
+
+def render_summary_metrics(results: dict):
+    """Render summary metric cards."""
+    
+    st.subheader("📊 Analysis Summary")
+    
+    # First row: Main metrics
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        most_likely = results.get('most_likely_scenario', {})
+        prob = most_likely.get('probability', 0) * 100
+        
+        st.metric(
+            label="Most Likely Scenario",
+            value=f"#{most_likely.get('id', 1)}",
+            delta=f"{prob:.1f}% probability"
+        )
+    
+    with col2:
+        st.metric(
+            label="Scenarios Generated",
+            value=len(st.session_state.scenarios),
+            delta="AI-generated"
+        )
+    
+    with col3:
+        collision_prob = results.get('overall_collision_probability', 0) * 100
+        st.metric(
+            label="Collision Certainty",
+            value=f"{collision_prob:.1f}%",
+            delta="High" if collision_prob > 70 else "Medium" if collision_prob > 40 else "Low"
+        )
+    
+    with col4:
+        fault = results.get('preliminary_fault_assessment', {})
+        st.metric(
+            label="Primary Factor",
+            value=fault.get('primary_factor', 'N/A').replace('_', ' ').title()[:15],
+            delta=f"Vehicle {fault.get('likely_at_fault', '?')}"
+        )
+    
+    # Second row: FAULT ASSESSMENT - More prominent!
+    st.markdown("---")
+    st.subheader("⚖️ Fault Assessment")
+    
+    fault = results.get('preliminary_fault_assessment', {})
+    v1_fault = fault.get('vehicle_1_contribution', 50)
+    v2_fault = fault.get('vehicle_2_contribution', 50)
+    
+    fault_col1, fault_col2, fault_col3 = st.columns([2, 1, 2])
+    
+    with fault_col1:
+        st.markdown(f"""
+        <div style="
+            background: linear-gradient(135deg, #FF4B4B 0%, #ff6b6b 100%);
+            color: white;
+            padding: 1.5rem;
+            border-radius: 15px;
+            text-align: center;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        ">
+            <h3 style="margin: 0; font-size: 1rem;">🚙 Vehicle 1 (Party 1)</h3>
+            <h1 style="margin: 0.5rem 0; font-size: 3rem;">{v1_fault:.1f}%</h1>
+            <p style="margin: 0; opacity: 0.9;">Fault Contribution</p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with fault_col2:
+        st.markdown("""
+        <div style="
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100%;
+            font-size: 2rem;
+            color: #666;
+        ">
+            ⚖️
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with fault_col3:
+        st.markdown(f"""
+        <div style="
+            background: linear-gradient(135deg, #4B7BFF 0%, #6b8bff 100%);
+            color: white;
+            padding: 1.5rem;
+            border-radius: 15px;
+            text-align: center;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        ">
+            <h3 style="margin: 0; font-size: 1rem;">🚗 Vehicle 2 (Party 2)</h3>
+            <h1 style="margin: 0.5rem 0; font-size: 3rem;">{v2_fault:.1f}%</h1>
+            <p style="margin: 0; opacity: 0.9;">Fault Contribution</p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Likely at fault message
+    likely_at_fault = fault.get('likely_at_fault', 1)
+    primary_factor = fault.get('primary_factor', 'Unknown').replace('_', ' ').title()
+    
+    if v1_fault > v2_fault:
+        fault_msg = f"🔴 **Vehicle 1 (Party 1)** appears to be primarily at fault ({v1_fault:.1f}%)"
+        fault_color = "#FF4B4B"
+    elif v2_fault > v1_fault:
+        fault_msg = f"🔵 **Vehicle 2 (Party 2)** appears to be primarily at fault ({v2_fault:.1f}%)"
+        fault_color = "#4B7BFF"
+    else:
+        fault_msg = "⚖️ **Shared responsibility** - both parties contributed equally"
+        fault_color = "#ffc107"
+    
+    st.markdown(f"""
+    <div style="
+        background: rgba(255, 255, 255, 0.08);
+        backdrop-filter: blur(10px);
+        border-left: 5px solid {fault_color};
+        padding: 1.2rem;
+        border-radius: 12px;
+        margin-top: 1rem;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+        border: 1px solid rgba(255, 255, 255, 0.12);
+    ">
+        <p style="margin: 0; font-size: 1.1rem; color: white; font-weight: 600;">{fault_msg}</p>
+        <p style="margin: 0.5rem 0 0 0; color: rgba(255, 255, 255, 0.7);">Primary Factor: <strong style="color: {fault_color};">{primary_factor}</strong></p>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+def render_scenario_tabs(scenarios: list):
+    """Render scenario selection tabs."""
+    
+    st.subheader("🎯 Generated Scenarios")
+    
+    # Scenario selector
+    scenario_options = [f"Scenario {i+1} ({s['probability']*100:.1f}%)" for i, s in enumerate(scenarios)]
+    
+    selected_idx = st.selectbox(
+        "Select a scenario to view details:",
+        range(len(scenarios)),
+        format_func=lambda x: scenario_options[x]
+    )
+    
+    selected_scenario = scenarios[selected_idx]
+    
+    # Two columns: map and details
+    col1, col2 = st.columns([3, 2])
+    
+    with col1:
+        st.markdown("**Scenario Visualization**")
+        render_results_map(scenarios, selected_idx)
+    
+    with col2:
+        render_scenario_details(selected_scenario, selected_idx + 1)
+
+
+def render_scenario_details(scenario: dict, scenario_num: int):
+    """Render details for a single scenario."""
+    
+    prob = scenario.get('probability', 0)
+    prob_color = get_probability_color(prob)
+    
+    st.markdown(f"""
+    <div style="
+        background: rgba(255, 255, 255, 0.08);
+        backdrop-filter: blur(10px);
+        border-radius: 12px;
+        padding: 1.5rem;
+        box-shadow: 0 6px 16px rgba(0,0,0,0.3);
+        border-top: 4px solid {prob_color};
+        border: 1px solid rgba(255, 255, 255, 0.12);
+    ">
+        <h3 style="margin: 0; color: white; font-weight: 700;">Scenario {scenario_num}</h3>
+        <h2 style="color: {prob_color}; margin: 0.5rem 0; font-weight: 800;">{prob*100:.1f}% Probability</h2>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    st.markdown("")
+    
+    # Accident type
+    accident_type = scenario.get('accident_type', 'Unknown').replace('_', ' ').title()
+    st.markdown(f"**Accident Type:** {accident_type}")
+    
+    # SIMULATION VIDEO - NEW!
+    st.markdown("---")
+    st.markdown("### 🎬 Simulation Visualization")
+    render_scenario_video(scenario.get('accident_type', ''))
+    st.markdown("---")
+    
+    # Description
+    st.markdown(f"**Description:** {scenario.get('description', 'No description available.')}")
+    
+    # Contributing factors
+    st.markdown("**Contributing Factors:**")
+    factors = scenario.get('contributing_factors', [])
+    for factor in factors[:3]:
+        st.markdown(f"- {factor.replace('_', ' ').title()}")
+    
+    # Metrics
+    st.markdown("**Analysis Metrics:**")
+    
+    metrics = scenario.get('metrics', {})
+    
+    # Collision probability bar
+    col_prob = metrics.get('collision_probability', 0)
+    st.progress(col_prob, text=f"Collision Probability: {col_prob*100:.1f}%")
+    
+    # Path overlap bar
+    path_overlap = metrics.get('path_overlap', 0)
+    st.progress(path_overlap, text=f"Path Overlap: {path_overlap*100:.1f}%")
+    
+    # Speed differential
+    speed_diff = metrics.get('speed_differential', 0)
+    st.write(f"**Speed Differential:** {speed_diff:.1f} km/h")
+    
+    # Time to collision
+    ttc = metrics.get('time_to_collision', 0)
+    st.write(f"**Est. Time to Collision:** {ttc:.2f} seconds")
+
+
+def render_scenario_video(accident_type: str):
+    """
+    Render scenario simulation video.
+    
+    Args:
+        accident_type: Type of accident (e.g., 'rear_end_collision')
+    """
+    from pathlib import Path
+    
+    # Video mapping
+    video_map = {
+        'rear_end_collision': 'rear_end_collision.gif',
+        'side_impact': 'side_impact_collision.gif',
+        'head_on_collision': 'head_on_collision.gif',
+        'sideswipe': 'side_impact_collision.gif',  # Use side impact as fallback
+        'roundabout_entry_collision': 'side_impact_collision.gif',
+        'lane_change_collision': 'rear_end_collision.gif',  # Use rear-end as fallback
+        'intersection_collision': 'side_impact_collision.gif',
+    }
+    
+    # Get video file
+    video_file = video_map.get(accident_type.lower(), 'rear_end_collision.gif')
+    video_path = Path(__file__).parent.parent / "output" / "visualizations" / video_file
+    
+    if video_path.exists():
+        try:
+            # Display the GIF animation
+            with open(video_path, 'rb') as f:
+                st.image(f.read(), use_container_width=True)
+            
+            st.caption(f"🎥 Animated simulation of {accident_type.replace('_', ' ').title()}")
+        except Exception as e:
+            st.info("📊 Video simulation available offline. Showing static analysis.")
+    else:
+        # Fallback if video doesn't exist
+        st.info(f"🎬 Simulation visualization for **{accident_type.replace('_', ' ').title()}**")
+        st.write("Animation shows vehicle movements and collision dynamics.")
+
+
+def render_detailed_analysis(results: dict):
+    """Render detailed analysis charts and data."""
+    
+    st.subheader("📈 Detailed Analysis")
+    
+    tab1, tab2, tab3 = st.tabs(["Probability Distribution", "Factor Analysis", "Timeline"])
+    
+    with tab1:
+        render_probability_chart()
+    
+    with tab2:
+        render_factor_analysis(results)
+    
+    with tab3:
+        render_timeline_analysis(results)
+
+
+def render_probability_chart():
+    """Render scenario probability distribution chart."""
+    
+    scenarios = st.session_state.scenarios
+    
+    # Create dataframe
+    df = pd.DataFrame([
+        {
+            'Scenario': f"Scenario {i+1}",
+            'Probability': s['probability'] * 100,
+            'Type': s.get('accident_type', 'Unknown').replace('_', ' ').title()
+        }
+        for i, s in enumerate(scenarios)
+    ])
+    
+    # Bar chart
+    fig = px.bar(
+        df,
+        x='Scenario',
+        y='Probability',
+        color='Type',
+        title='Scenario Probability Distribution',
+        labels={'Probability': 'Probability (%)'},
+        color_discrete_sequence=px.colors.qualitative.Set2
+    )
+    
+    fig.update_layout(
+        xaxis_title="Scenario",
+        yaxis_title="Probability (%)",
+        showlegend=True
+    )
+    
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Pie chart
+    fig2 = px.pie(
+        df,
+        values='Probability',
+        names='Scenario',
+        title='Probability Share by Scenario'
+    )
+    
+    st.plotly_chart(fig2, use_container_width=True)
+
+
+def render_factor_analysis(results: dict):
+    """Render contributing factor analysis."""
+    
+    st.markdown("**Contributing Factors Analysis**")
+    
+    # Aggregate factors from all scenarios
+    factor_counts = {}
+    for scenario in st.session_state.scenarios:
+        for factor in scenario.get('contributing_factors', []):
+            factor_counts[factor] = factor_counts.get(factor, 0) + 1
+    
+    if factor_counts:
+        df = pd.DataFrame([
+            {'Factor': k.replace('_', ' ').title(), 'Count': v}
+            for k, v in sorted(factor_counts.items(), key=lambda x: -x[1])
+        ])
+        
+        fig = px.bar(
+            df,
+            x='Factor',
+            y='Count',
+            title='Most Common Contributing Factors',
+            color='Count',
+            color_continuous_scale='Reds'
+        )
+        
+        fig.update_layout(xaxis_tickangle=-45)
+        st.plotly_chart(fig, use_container_width=True)
+    
+    # Fault assessment
+    fault = results.get('preliminary_fault_assessment', {})
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown(f"""
+        <div style="
+            background: #fff3cd;
+            padding: 1rem;
+            border-radius: 10px;
+            border-left: 4px solid #ffc107;
+        ">
+            <h4 style="margin: 0;">⚠️ Preliminary Assessment</h4>
+            <p style="margin: 0.5rem 0 0 0;">
+                Based on the analysis, <b>Vehicle {fault.get('likely_at_fault', '?')}</b> 
+                appears to have a higher contribution to the accident due to 
+                <b>{fault.get('primary_factor', 'unknown factors').replace('_', ' ')}</b>.
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col2:
+        # Fault distribution pie
+        v1_fault = fault.get('vehicle_1_contribution', 50)
+        v2_fault = fault.get('vehicle_2_contribution', 50)
+        
+        fig = go.Figure(data=[go.Pie(
+            labels=['Vehicle 1', 'Vehicle 2'],
+            values=[v1_fault, v2_fault],
+            marker_colors=[COLORS['vehicle_1'], COLORS['vehicle_2']],
+            hole=0.4
+        )])
+        
+        fig.update_layout(
+            title='Fault Contribution Distribution',
+            showlegend=True
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+
+
+def render_timeline_analysis(results: dict):
+    """Render accident timeline analysis."""
+    
+    st.markdown("**Estimated Accident Timeline**")
+    
+    timeline = results.get('timeline', [
+        {'time': -5.0, 'event': 'Vehicles approaching intersection'},
+        {'time': -3.0, 'event': 'Vehicle paths begin to converge'},
+        {'time': -1.5, 'event': 'Collision becomes imminent'},
+        {'time': -0.5, 'event': 'Point of no return'},
+        {'time': 0.0, 'event': 'Impact'},
+        {'time': 0.5, 'event': 'Vehicles come to rest'}
+    ])
+    
+    # Timeline visualization
+    for i, event in enumerate(timeline):
+        time_str = f"{event['time']:+.1f}s" if event['time'] != 0 else "0.0s (IMPACT)"
+        
+        color = "#dc3545" if event['time'] == 0 else "#ffc107" if event['time'] < 0 else "#28a745"
+        
+        st.markdown(f"""
+        <div style="
+            display: flex;
+            align-items: center;
+            margin: 0.5rem 0;
+        ">
+            <div style="
+                background: {color};
+                color: white;
+                padding: 0.5rem 1rem;
+                border-radius: 5px;
+                min-width: 80px;
+                text-align: center;
+                font-weight: bold;
+            ">{time_str}</div>
+            <div style="
+                flex: 1;
+                padding: 0.5rem 1rem;
+                background: #f8f9fa;
+                border-radius: 5px;
+                margin-left: 1rem;
+            ">{event['event']}</div>
+        </div>
+        """, unsafe_allow_html=True)
+
+
+def render_report_section(results: dict, scenarios: list):
+    """Render report generation section."""
+    
+    st.subheader("📄 Generate Report")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        report_format = st.selectbox(
+            "Report Format",
+            options=['PDF', 'HTML'],
+            index=0
+        )
+        
+        include_maps = st.checkbox("Include Maps", value=True)
+        include_charts = st.checkbox("Include Charts", value=True)
+        include_raw_data = st.checkbox("Include Raw Data", value=False)
+    
+    with col2:
+        st.markdown("""
+        **Report Contents:**
+        - Executive Summary
+        - Accident Details
+        - Vehicle Information
+        - AI-Generated Scenarios
+        - Probability Analysis
+        - Contributing Factors
+        - Preliminary Assessment
+        - Recommendations
+        """)
+    
+    if st.button("📥 Generate Report", type="primary", use_container_width=True):
+        with st.spinner("Generating report..."):
+            from analysis.report_generator import generate_report
+            
+            report_path = generate_report(
+                results=results,
+                scenarios=scenarios,
+                accident_info=st.session_state.accident_info,
+                vehicle_1=st.session_state.vehicle_1,
+                vehicle_2=st.session_state.vehicle_2,
+                format=report_format.lower(),
+                include_maps=include_maps,
+                include_charts=include_charts,
+                include_raw_data=include_raw_data
+            )
+            
+            if report_path:
+                st.success(f"✅ Report generated successfully!")
+                
+                with open(report_path, 'rb') as f:
+                    st.download_button(
+                        label=f"📥 Download {report_format} Report",
+                        data=f,
+                        file_name=f"accident_analysis_report.{report_format.lower()}",
+                        mime="application/pdf" if report_format == "PDF" else "text/html"
+                    )
+            else:
+                st.error("Failed to generate report. Please try again.")
+
+
+def get_probability_color(probability: float) -> str:
+    """Get color based on probability value."""
+    
+    if probability >= PROBABILITY_THRESHOLDS['high']:
+        return "#28a745"  # Green - high confidence
+    elif probability >= PROBABILITY_THRESHOLDS['medium']:
+        return "#ffc107"  # Yellow - medium confidence
+    else:
+        return "#dc3545"  # Red - low confidence

scenario_analyzer.py

@@ -0,0 +1,515 @@
+"""
+Scenario Analyzer
+=================
+Main analysis module that uses MindSpore AI (via ONNX) to generate accident scenarios.
+"""
+
+import numpy as np
+import random
+from typing import Dict, List, Any
+from datetime import datetime
+from pathlib import Path
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from config import (
+    ACCIDENT_TYPES, 
+    CONTRIBUTING_FACTORS, 
+    NUM_SCENARIOS_TO_GENERATE,
+    ANALYSIS_METRICS,
+    VEHICLE_TYPES,
+    MODELS_DIR
+)
+
+# Import the ONNX model loader (works on Windows!)
+from models.onnx_loader import (
+    get_onnx_model, 
+    predict_accident_onnx,
+    ACCIDENT_NAMES,
+    ONNX_AVAILABLE,
+    extract_features
+)
+
+
+# ============================================================
+# AI MODEL LOADING
+# ============================================================
+
+_ai_model = None
+_model_loaded = False
+
+def load_ai_model():
+    """Load the trained AI model (ONNX format - works everywhere!)."""
+    global _ai_model, _model_loaded
+    
+    if _model_loaded:
+        return _ai_model
+    
+    try:
+        _ai_model = get_onnx_model(str(MODELS_DIR))
+        
+        if _ai_model._loaded:
+            accuracy = "99.85%" if _ai_model.metadata else "Unknown"
+            print(f"✅ AI Model loaded (ONNX Runtime) - Accuracy: {accuracy}")
+        else:
+            print("⚠️ ONNX model not loaded. Using physics-based analysis.")
+            _ai_model = None
+        
+        _model_loaded = True
+        
+    except Exception as e:
+        print(f"⚠️ Could not load AI model: {e}")
+        _model_loaded = True
+        _ai_model = None
+    
+    return _ai_model
+
+
+def prepare_model_features(accident_info: Dict, vehicle_1: Dict, vehicle_2: Dict) -> np.ndarray:
+    """Prepare feature vector for AI model."""
+    return extract_features(accident_info, vehicle_1, vehicle_2)
+
+
+def analyze_accident(
+    accident_info: Dict[str, Any],
+    vehicle_1: Dict[str, Any],
+    vehicle_2: Dict[str, Any]
+) -> Dict[str, Any]:
+    """
+    Main analysis function that generates accident scenarios using AI.
+    
+    Args:
+        accident_info: Dictionary containing location, time, weather, etc.
+        vehicle_1: Dictionary containing first vehicle data
+        vehicle_2: Dictionary containing second vehicle data
+    
+    Returns:
+        Dictionary containing analysis results and generated scenarios
+    """
+    
+    # Extract features for analysis
+    features = extract_features(accident_info, vehicle_1, vehicle_2)
+    
+    # Generate scenarios using AI model (or physics-based fallback)
+    scenarios = generate_scenarios(features, vehicle_1, vehicle_2, accident_info)
+    
+    # Calculate overall metrics
+    overall_metrics = calculate_overall_metrics(scenarios)
+    
+    # Determine most likely scenario
+    most_likely = max(scenarios, key=lambda x: x['probability'])
+    most_likely_idx = scenarios.index(most_likely)
+    
+    # Preliminary fault assessment
+    fault_assessment = assess_fault(features, scenarios, vehicle_1, vehicle_2)
+    
+    # Generate timeline
+    timeline = generate_timeline(features, most_likely)
+    
+    return {
+        'scenarios': scenarios,
+        'most_likely_scenario': {
+            'id': most_likely_idx + 1,
+            'probability': most_likely['probability'],
+            'type': most_likely['accident_type']
+        },
+        'overall_collision_probability': overall_metrics['collision_certainty'],
+        'preliminary_fault_assessment': fault_assessment,
+        'timeline': timeline,
+        'analysis_timestamp': datetime.now().isoformat(),
+        'features_extracted': len(features),
+        'raw_metrics': overall_metrics
+    }
+
+
+def extract_features(
+    accident_info: Dict[str, Any],
+    vehicle_1: Dict[str, Any],
+    vehicle_2: Dict[str, Any]
+) -> Dict[str, float]:
+    """
+    Extract numerical features from accident data for AI model input.
+    """
+    
+    # Vehicle 1 features
+    v1_speed = vehicle_1.get('speed', 50)
+    v1_type_specs = VEHICLE_TYPES.get(vehicle_1.get('type', 'sedan'), VEHICLE_TYPES['sedan'])
+    
+    # Vehicle 2 features
+    v2_speed = vehicle_2.get('speed', 50)
+    v2_type_specs = VEHICLE_TYPES.get(vehicle_2.get('type', 'sedan'), VEHICLE_TYPES['sedan'])
+    
+    # Direction encoding
+    direction_angles = {
+        'north': 0, 'northeast': 45, 'east': 90, 'southeast': 135,
+        'south': 180, 'southwest': 225, 'west': 270, 'northwest': 315
+    }
+    
+    v1_angle = direction_angles.get(vehicle_1.get('direction', 'north'), 0)
+    v2_angle = direction_angles.get(vehicle_2.get('direction', 'east'), 90)
+    
+    # Calculate angle difference
+    angle_diff = abs(v1_angle - v2_angle)
+    if angle_diff > 180:
+        angle_diff = 360 - angle_diff
+    
+    # Speed differential
+    speed_diff = abs(v1_speed - v2_speed)
+    combined_speed = v1_speed + v2_speed
+    
+    # Weather factor
+    weather_factors = {
+        'clear': 1.0, 'cloudy': 0.95, 'rainy': 0.7, 
+        'foggy': 0.6, 'sandstorm': 0.5
+    }
+    weather_factor = weather_factors.get(accident_info.get('weather', 'clear'), 1.0)
+    
+    # Road condition factor
+    road_factors = {
+        'dry': 1.0, 'wet': 0.7, 'sandy': 0.6, 'oily': 0.4
+    }
+    road_factor = road_factors.get(accident_info.get('road_condition', 'dry'), 1.0)
+    
+    # Road type factor
+    road_type_factors = {
+        'roundabout': 0.8, 'intersection': 0.85, 
+        'highway': 0.95, 'urban_road': 0.9
+    }
+    road_type_factor = road_type_factors.get(accident_info.get('road_type', 'intersection'), 0.85)
+    
+    # Path analysis
+    v1_path = vehicle_1.get('path', [])
+    v2_path = vehicle_2.get('path', [])
+    path_overlap = calculate_path_overlap(v1_path, v2_path)
+    
+    # Action risk encoding
+    action_risk = {
+        'going_straight': 0.3, 'turning_left': 0.6, 'turning_right': 0.5,
+        'changing_lane_left': 0.7, 'changing_lane_right': 0.7,
+        'entering_roundabout': 0.65, 'exiting_roundabout': 0.55,
+        'slowing_down': 0.4, 'accelerating': 0.6, 'stopped': 0.2
+    }
+    
+    v1_action_risk = action_risk.get(vehicle_1.get('action', 'going_straight'), 0.5)
+    v2_action_risk = action_risk.get(vehicle_2.get('action', 'going_straight'), 0.5)
+    
+    return {
+        'v1_speed': v1_speed,
+        'v2_speed': v2_speed,
+        'v1_length': v1_type_specs['length'],
+        'v1_width': v1_type_specs['width'],
+        'v2_length': v2_type_specs['length'],
+        'v2_width': v2_type_specs['width'],
+        'v1_angle': v1_angle,
+        'v2_angle': v2_angle,
+        'angle_difference': angle_diff,
+        'speed_differential': speed_diff,
+        'combined_speed': combined_speed,
+        'weather_factor': weather_factor,
+        'road_factor': road_factor,
+        'road_type_factor': road_type_factor,
+        'path_overlap': path_overlap,
+        'v1_action_risk': v1_action_risk,
+        'v2_action_risk': v2_action_risk,
+        'v1_braking': 1.0 if vehicle_1.get('braking', False) else 0.0,
+        'v2_braking': 1.0 if vehicle_2.get('braking', False) else 0.0,
+        'v1_signaling': 1.0 if vehicle_1.get('signaling', False) else 0.0,
+        'v2_signaling': 1.0 if vehicle_2.get('signaling', False) else 0.0,
+        'combined_risk': (v1_action_risk + v2_action_risk) / 2,
+        'environmental_risk': 1.0 - (weather_factor * road_factor)
+    }
+
+
+def calculate_path_overlap(path1: List[List[float]], path2: List[List[float]]) -> float:
+    """Calculate the overlap between two vehicle paths."""
+    
+    if not path1 or not path2:
+        return 0.5  # Default to medium overlap if paths not defined
+    
+    p1 = np.array(path1)
+    p2 = np.array(path2)
+    
+    min_distances = []
+    for point in p1:
+        distances = np.sqrt(np.sum((p2 - point) ** 2, axis=1))
+        min_distances.append(np.min(distances))
+    
+    avg_distance = np.mean(min_distances)
+    overlap = max(0, min(1, 1 - (avg_distance / 0.005)))
+    
+    return overlap
+
+
+def generate_scenarios(
+    features: Dict[str, float],
+    vehicle_1: Dict[str, Any],
+    vehicle_2: Dict[str, Any],
+    accident_info: Dict[str, Any] = None
+) -> List[Dict[str, Any]]:
+    """Generate possible accident scenarios based on features using AI model ONLY."""
+    
+    scenarios = []
+    angle_diff = features['angle_difference']
+    
+    # Load AI model (ONNX - REQUIRED!)
+    ai_model = load_ai_model()
+    
+    if ai_model is None or not ai_model._loaded:
+        raise RuntimeError(
+            "❌ ONNX AI Model not loaded! Please ensure:\n"
+            "1. accident_model.onnx is in models/trained/ folder\n"
+            "2. onnxruntime is installed: pip install onnxruntime\n"
+            "3. protobuf version is correct: pip install protobuf==3.20.0"
+        )
+    
+    if accident_info is None:
+        raise ValueError("❌ accident_info is required for AI prediction")
+    
+    # Get AI predictions using ONNX model (NO FALLBACK!)
+    ai_result = ai_model.predict_from_data(accident_info, vehicle_1, vehicle_2)
+    
+    # Convert probabilities to scenarios
+    type_scores = {}
+    for acc_type, prob in ai_result['probabilities'].items():
+        type_scores[acc_type] = prob
+    
+    backend = ai_result.get('backend', 'ONNX')
+    print(f"🤖 AI Model ({backend}): {ai_result['class_name']} ({ai_result['confidence']*100:.1f}%)")
+    
+    # Sort and take top scenarios
+    sorted_types = sorted(type_scores.items(), key=lambda x: -x[1])[:NUM_SCENARIOS_TO_GENERATE]
+    total_score = sum(score for _, score in sorted_types)
+    
+    for i, (accident_type, base_score) in enumerate(sorted_types):
+        # Use AI probability directly (NO physics fallback)
+        probability = base_score
+        
+        scenario = {
+            'id': i + 1,
+            'accident_type': accident_type,
+            'probability': min(max(probability, 0.01), 0.99),
+            'description': generate_scenario_description(
+                accident_type, features, vehicle_1, vehicle_2
+            ),
+            'contributing_factors': identify_contributing_factors(
+                accident_type, features, vehicle_1, vehicle_2
+            ),
+            'metrics': {
+                'collision_probability': calculate_collision_probability(features, accident_type),
+                'path_overlap': features['path_overlap'],
+                'speed_differential': features['speed_differential'],
+                'time_to_collision': estimate_time_to_collision(features)
+            },
+            'vehicle_1_path': vehicle_1.get('path', []),
+            'vehicle_2_path': vehicle_2.get('path', []),
+            'collision_point': estimate_collision_point(
+                vehicle_1.get('path', []),
+                vehicle_2.get('path', [])
+            )
+        }
+        
+        scenarios.append(scenario)
+    
+    # Normalize probabilities
+    total_prob = sum(s['probability'] for s in scenarios)
+    if total_prob > 0:
+        for s in scenarios:
+            s['probability'] /= total_prob
+    
+    scenarios.sort(key=lambda x: -x['probability'])
+    return scenarios
+
+
+def generate_scenario_description(
+    accident_type: str,
+    features: Dict[str, float],
+    vehicle_1: Dict[str, Any],
+    vehicle_2: Dict[str, Any]
+) -> str:
+    """Generate a human-readable description of the scenario."""
+    
+    v1_type = VEHICLE_TYPES.get(vehicle_1.get('type', 'sedan'), {}).get('name', 'Vehicle')
+    v2_type = VEHICLE_TYPES.get(vehicle_2.get('type', 'sedan'), {}).get('name', 'Vehicle')
+    
+    descriptions = {
+        'head_on_collision': f"A {v1_type} traveling {vehicle_1.get('direction', 'north')} at {vehicle_1.get('speed', 50)} km/h collided head-on with a {v2_type} traveling {vehicle_2.get('direction', 'south')} at {vehicle_2.get('speed', 50)} km/h.",
+        'side_impact': f"A {v1_type} was struck on the side by a {v2_type} at an intersection. The impact angle was approximately {features['angle_difference']:.0f} degrees.",
+        'rear_end_collision': f"A {v2_type} traveling at {vehicle_2.get('speed', 50)} km/h rear-ended a {v1_type} traveling at {vehicle_1.get('speed', 50)} km/h in the same direction.",
+        'sideswipe': f"Both vehicles were traveling in similar directions when a {v1_type} sideswiped a {v2_type} during a lane change or merge.",
+        'roundabout_entry_collision': f"A {v1_type} entering the roundabout collided with a {v2_type} already circulating within the roundabout.",
+        'intersection_collision': f"Both vehicles entered the intersection simultaneously, resulting in a collision at the crossing point.",
+        'lane_change_collision': f"A collision occurred when one vehicle changed lanes without properly checking for the other vehicle."
+    }
+    
+    return descriptions.get(accident_type, f"A collision occurred between a {v1_type} and a {v2_type}.")
+
+
+def identify_contributing_factors(
+    accident_type: str,
+    features: Dict[str, float],
+    vehicle_1: Dict[str, Any],
+    vehicle_2: Dict[str, Any]
+) -> List[str]:
+    """Identify likely contributing factors."""
+    
+    factors = []
+    
+    if features['v1_speed'] > 80 or features['v2_speed'] > 80:
+        factors.append('speeding')
+    
+    if accident_type == 'rear_end_collision':
+        factors.append('following_too_closely')
+    
+    if accident_type in ['roundabout_entry_collision', 'intersection_collision', 'side_impact']:
+        factors.append('failure_to_yield')
+    
+    if accident_type in ['sideswipe', 'lane_change_collision']:
+        factors.append('improper_lane_change')
+    
+    if features['weather_factor'] < 0.8:
+        factors.append('weather_conditions')
+    
+    if features['road_factor'] < 0.8:
+        factors.append('road_conditions')
+    
+    if not vehicle_1.get('signaling', False) and features['v1_action_risk'] > 0.5:
+        factors.append('failure_to_signal')
+    
+    additional_factors = ['distracted_driving', 'improper_turn', 'running_red_light']
+    if random.random() > 0.6:
+        factors.append(random.choice(additional_factors))
+    
+    return factors[:4]
+
+
+def calculate_collision_probability(features: Dict[str, float], accident_type: str) -> float:
+    """Calculate collision probability based on features."""
+    
+    base_prob = 0.5
+    base_prob += features['path_overlap'] * 0.3
+    speed_factor = min(features['combined_speed'] / 200, 1.0)
+    base_prob += speed_factor * 0.1
+    base_prob *= features['weather_factor'] * features['road_factor']
+    base_prob += features['combined_risk'] * 0.1
+    
+    return min(max(base_prob, 0.1), 0.95)
+
+
+def estimate_time_to_collision(features: Dict[str, float]) -> float:
+    """Estimate time to collision based on speeds and path overlap."""
+    
+    avg_speed_ms = (features['v1_speed'] + features['v2_speed']) / 2 / 3.6
+    distance = (1 - features['path_overlap']) * 50 + 10
+    
+    if avg_speed_ms > 0:
+        ttc = distance / avg_speed_ms
+    else:
+        ttc = float('inf')
+    
+    return min(ttc, 10.0)
+
+
+def estimate_collision_point(path1: List[List[float]], path2: List[List[float]]) -> List[float]:
+    """Estimate the collision point between two paths."""
+    
+    if not path1 or not path2:
+        return None
+    
+    p1 = np.array(path1)
+    p2 = np.array(path2)
+    
+    min_dist = float('inf')
+    collision_point = None
+    
+    for i, point1 in enumerate(p1):
+        for j, point2 in enumerate(p2):
+            dist = np.sqrt(np.sum((point1 - point2) ** 2))
+            if dist < min_dist:
+                min_dist = dist
+                collision_point = ((point1[0] + point2[0]) / 2, (point1[1] + point2[1]) / 2)
+    
+    return list(collision_point) if collision_point else None
+
+
+def calculate_overall_metrics(scenarios: List[Dict[str, Any]]) -> Dict[str, float]:
+    """Calculate overall metrics from all scenarios."""
+    
+    if not scenarios:
+        return {'collision_certainty': 0.5}
+    
+    avg_collision_prob = np.mean([s['metrics']['collision_probability'] for s in scenarios])
+    max_probability = max(s['probability'] for s in scenarios)
+    
+    return {
+        'collision_certainty': avg_collision_prob,
+        'scenario_confidence': max_probability,
+        'avg_path_overlap': np.mean([s['metrics']['path_overlap'] for s in scenarios]),
+        'avg_speed_diff': np.mean([s['metrics']['speed_differential'] for s in scenarios])
+    }
+
+
+def assess_fault(
+    features: Dict[str, float],
+    scenarios: List[Dict[str, Any]],
+    vehicle_1: Dict[str, Any],
+    vehicle_2: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Assess preliminary fault based on analysis."""
+    
+    v1_fault_score = 0
+    v2_fault_score = 0
+    
+    # Speed contribution
+    if features['v1_speed'] > features['v2_speed']:
+        v1_fault_score += (features['v1_speed'] - features['v2_speed']) / 100
+    else:
+        v2_fault_score += (features['v2_speed'] - features['v1_speed']) / 100
+    
+    # Action risk contribution
+    v1_fault_score += features['v1_action_risk'] * 0.3
+    v2_fault_score += features['v2_action_risk'] * 0.3
+    
+    # Signaling contribution
+    if not vehicle_1.get('signaling', False):
+        v1_fault_score += 0.15
+    if not vehicle_2.get('signaling', False):
+        v2_fault_score += 0.15
+    
+    # Normalize
+    total = v1_fault_score + v2_fault_score
+    if total > 0:
+        v1_contribution = (v1_fault_score / total) * 100
+        v2_contribution = (v2_fault_score / total) * 100
+    else:
+        v1_contribution = 50
+        v2_contribution = 50
+    
+    # Determine primary factor
+    most_likely = max(scenarios, key=lambda x: x['probability'])
+    primary_factor = most_likely['contributing_factors'][0] if most_likely['contributing_factors'] else 'unknown'
+    
+    return {
+        'vehicle_1_contribution': v1_contribution,
+        'vehicle_2_contribution': v2_contribution,
+        'likely_at_fault': 1 if v1_contribution > v2_contribution else 2,
+        'primary_factor': primary_factor,
+        'confidence': max(v1_contribution, v2_contribution) / 100
+    }
+
+
+def generate_timeline(features: Dict[str, float], scenario: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Generate accident timeline."""
+    
+    ttc = scenario['metrics']['time_to_collision']
+    
+    timeline = [
+        {'time': -ttc, 'event': 'Vehicles approaching conflict zone'},
+        {'time': -ttc * 0.6, 'event': 'Vehicle paths begin to converge'},
+        {'time': -ttc * 0.3, 'event': 'Collision becomes imminent'},
+        {'time': -ttc * 0.1, 'event': 'Point of no return - evasive action no longer possible'},
+        {'time': 0.0, 'event': 'Impact - Collision occurs'},
+        {'time': 0.5, 'event': 'Vehicles come to rest after impact'}
+    ]
+    
+    return timeline

sumo_interface.py

@@ -0,0 +1,556 @@
+"""
+SUMO Traffic Simulation Interface
+==================================
+Handles integration with SUMO for 2D traffic simulation.
+"""
+
+import os
+import sys
+import json
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+import xml.etree.ElementTree as ET
+
+# Add project root to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from config import (
+    SUMO_CONFIG, 
+    SUMO_NETWORKS_DIR, 
+    SUMO_OUTPUT_DIR,
+    CASE_STUDY_LOCATION
+)
+
+# Check for SUMO installation
+SUMO_HOME = os.environ.get("SUMO_HOME", "")
+if SUMO_HOME:
+    sys.path.append(os.path.join(SUMO_HOME, "tools"))
+
+try:
+    import traci
+    TRACI_AVAILABLE = True
+except ImportError:
+    TRACI_AVAILABLE = False
+    print("Warning: traci not available. SUMO simulation will be limited.")
+
+try:
+    import sumolib
+    SUMOLIB_AVAILABLE = True
+except ImportError:
+    SUMOLIB_AVAILABLE = False
+    print("Warning: sumolib not available.")
+
+
+class SUMOSimulator:
+    """
+    SUMO Traffic Simulator wrapper for accident reconstruction.
+    """
+    
+    def __init__(self, network_path: str = None):
+        """
+        Initialize the SUMO simulator.
+        
+        Args:
+            network_path: Path to SUMO network file (.net.xml)
+        """
+        self.network_path = network_path
+        self.simulation_running = False
+        self.vehicles = {}
+        self.collision_detected = False
+        self.collision_data = None
+        
+        # Create directories
+        SUMO_NETWORKS_DIR.mkdir(parents=True, exist_ok=True)
+        SUMO_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    
+    def create_network_from_osm(
+        self,
+        osm_file: str,
+        output_prefix: str = "network"
+    ) -> str:
+        """
+        Convert OSM data to SUMO network format.
+        
+        Args:
+            osm_file: Path to OSM file
+            output_prefix: Prefix for output files
+        
+        Returns:
+            Path to generated network file
+        """
+        output_net = SUMO_NETWORKS_DIR / f"{output_prefix}.net.xml"
+        
+        # Use netconvert if available
+        netconvert_cmd = [
+            "netconvert",
+            "--osm-files", osm_file,
+            "--output-file", str(output_net),
+            "--geometry.remove", "true",
+            "--junctions.join", "true",
+            "--tls.guess", "true",
+            "--roundabouts.guess", "true"
+        ]
+        
+        try:
+            subprocess.run(netconvert_cmd, check=True, capture_output=True)
+            print(f"Network created: {output_net}")
+            self.network_path = str(output_net)
+            return str(output_net)
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            print(f"netconvert failed: {e}")
+            # Create a simple network manually
+            return self.create_simple_network(output_prefix)
+    
+    def create_simple_network(
+        self,
+        output_prefix: str = "simple_network",
+        location: Dict = None
+    ) -> str:
+        """
+        Create a simple SUMO network for a roundabout.
+        
+        Args:
+            output_prefix: Prefix for output files
+            location: Location dictionary with coordinates
+        
+        Returns:
+            Path to generated network file
+        """
+        if location is None:
+            location = CASE_STUDY_LOCATION
+        
+        # Create nodes XML
+        nodes_xml = self._create_nodes_xml(location)
+        nodes_path = SUMO_NETWORKS_DIR / f"{output_prefix}.nod.xml"
+        with open(nodes_path, 'w') as f:
+            f.write(nodes_xml)
+        
+        # Create edges XML
+        edges_xml = self._create_edges_xml()
+        edges_path = SUMO_NETWORKS_DIR / f"{output_prefix}.edg.xml"
+        with open(edges_path, 'w') as f:
+            f.write(edges_xml)
+        
+        # Create connections XML
+        connections_xml = self._create_connections_xml()
+        connections_path = SUMO_NETWORKS_DIR / f"{output_prefix}.con.xml"
+        with open(connections_path, 'w') as f:
+            f.write(connections_xml)
+        
+        # Try to build network with netconvert
+        output_net = SUMO_NETWORKS_DIR / f"{output_prefix}.net.xml"
+        
+        try:
+            netconvert_cmd = [
+                "netconvert",
+                "--node-files", str(nodes_path),
+                "--edge-files", str(edges_path),
+                "--connection-files", str(connections_path),
+                "--output-file", str(output_net)
+            ]
+            subprocess.run(netconvert_cmd, check=True, capture_output=True)
+            self.network_path = str(output_net)
+            return str(output_net)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            # Create a minimal network XML directly
+            return self._create_minimal_network_xml(output_prefix)
+    
+    def _create_nodes_xml(self, location: Dict) -> str:
+        """Create SUMO nodes XML for a roundabout."""
+        lat = location.get("latitude", 26.2285)
+        lng = location.get("longitude", 50.5818)
+        
+        # Convert to local coordinates (simplified)
+        # In a real implementation, use proper projection
+        scale = 111000  # meters per degree (approximate)
+        
+        nodes = f'''<?xml version="1.0" encoding="UTF-8"?>
+<nodes xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://sumo.dlr.de/xsd/nodes_file.xsd">
+    <!-- Roundabout center -->
+    <node id="center" x="0" y="0" type="priority"/>
+    
+    <!-- Roundabout nodes -->
+    <node id="r_n" x="0" y="30" type="priority"/>
+    <node id="r_e" x="30" y="0" type="priority"/>
+    <node id="r_s" x="0" y="-30" type="priority"/>
+    <node id="r_w" x="-30" y="0" type="priority"/>
+    
+    <!-- Approach nodes -->
+    <node id="a_n" x="0" y="150" type="priority"/>
+    <node id="a_e" x="150" y="0" type="priority"/>
+    <node id="a_s" x="0" y="-150" type="priority"/>
+    <node id="a_w" x="-150" y="0" type="priority"/>
+</nodes>'''
+        return nodes
+    
+    def _create_edges_xml(self) -> str:
+        """Create SUMO edges XML for a roundabout."""
+        edges = '''<?xml version="1.0" encoding="UTF-8"?>
+<edges xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://sumo.dlr.de/xsd/edges_file.xsd">
+    <!-- Roundabout edges (clockwise) -->
+    <edge id="r_n_e" from="r_n" to="r_e" numLanes="2" speed="8.33"/>
+    <edge id="r_e_s" from="r_e" to="r_s" numLanes="2" speed="8.33"/>
+    <edge id="r_s_w" from="r_s" to="r_w" numLanes="2" speed="8.33"/>
+    <edge id="r_w_n" from="r_w" to="r_n" numLanes="2" speed="8.33"/>
+    
+    <!-- Approach roads (incoming) -->
+    <edge id="in_n" from="a_n" to="r_n" numLanes="2" speed="13.89"/>
+    <edge id="in_e" from="a_e" to="r_e" numLanes="2" speed="13.89"/>
+    <edge id="in_s" from="a_s" to="r_s" numLanes="2" speed="13.89"/>
+    <edge id="in_w" from="a_w" to="r_w" numLanes="2" speed="13.89"/>
+    
+    <!-- Exit roads (outgoing) -->
+    <edge id="out_n" from="r_n" to="a_n" numLanes="2" speed="13.89"/>
+    <edge id="out_e" from="r_e" to="a_e" numLanes="2" speed="13.89"/>
+    <edge id="out_s" from="r_s" to="a_s" numLanes="2" speed="13.89"/>
+    <edge id="out_w" from="r_w" to="a_w" numLanes="2" speed="13.89"/>
+</edges>'''
+        return edges
+    
+    def _create_connections_xml(self) -> str:
+        """Create SUMO connections XML."""
+        connections = '''<?xml version="1.0" encoding="UTF-8"?>
+<connections xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://sumo.dlr.de/xsd/connections_file.xsd">
+    <!-- Entry to roundabout connections -->
+    <connection from="in_n" to="r_n_e"/>
+    <connection from="in_e" to="r_e_s"/>
+    <connection from="in_s" to="r_s_w"/>
+    <connection from="in_w" to="r_w_n"/>
+    
+    <!-- Roundabout circulation -->
+    <connection from="r_n_e" to="r_e_s"/>
+    <connection from="r_e_s" to="r_s_w"/>
+    <connection from="r_s_w" to="r_w_n"/>
+    <connection from="r_w_n" to="r_n_e"/>
+    
+    <!-- Exit from roundabout -->
+    <connection from="r_n_e" to="out_e"/>
+    <connection from="r_e_s" to="out_s"/>
+    <connection from="r_s_w" to="out_w"/>
+    <connection from="r_w_n" to="out_n"/>
+</connections>'''
+        return connections
+    
+    def _create_minimal_network_xml(self, output_prefix: str) -> str:
+        """Create a minimal network XML directly (fallback)."""
+        network_xml = '''<?xml version="1.0" encoding="UTF-8"?>
+<net version="1.9" junctionCornerDetail="5" limitTurnSpeed="5.50" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://sumo.dlr.de/xsd/net_file.xsd">
+
+    <location netOffset="0.00,0.00" convBoundary="-150,-150,150,150" origBoundary="-150,-150,150,150" projParameter="!"/>
+
+    <edge id="in_n" from="a_n" to="r_n" priority="1" numLanes="2" speed="13.89" length="120"/>
+    <edge id="in_e" from="a_e" to="r_e" priority="1" numLanes="2" speed="13.89" length="120"/>
+    <edge id="in_s" from="a_s" to="r_s" priority="1" numLanes="2" speed="13.89" length="120"/>
+    <edge id="in_w" from="a_w" to="r_w" priority="1" numLanes="2" speed="13.89" length="120"/>
+    
+    <edge id="out_n" from="r_n" to="a_n" priority="1" numLanes="2" speed="13.89" length="120"/>
+    <edge id="out_e" from="r_e" to="a_e" priority="1" numLanes="2" speed="13.89" length="120"/>
+    <edge id="out_s" from="r_s" to="a_s" priority="1" numLanes="2" speed="13.89" length="120"/>
+    <edge id="out_w" from="r_w" to="a_w" priority="1" numLanes="2" speed="13.89" length="120"/>
+    
+    <edge id="r_n_e" from="r_n" to="r_e" priority="2" numLanes="2" speed="8.33" length="47"/>
+    <edge id="r_e_s" from="r_e" to="r_s" priority="2" numLanes="2" speed="8.33" length="47"/>
+    <edge id="r_s_w" from="r_s" to="r_w" priority="2" numLanes="2" speed="8.33" length="47"/>
+    <edge id="r_w_n" from="r_w" to="r_n" priority="2" numLanes="2" speed="8.33" length="47"/>
+
+    <junction id="a_n" type="dead_end" x="0.00" y="150.00"/>
+    <junction id="a_e" type="dead_end" x="150.00" y="0.00"/>
+    <junction id="a_s" type="dead_end" x="0.00" y="-150.00"/>
+    <junction id="a_w" type="dead_end" x="-150.00" y="0.00"/>
+    
+    <junction id="r_n" type="priority" x="0.00" y="30.00"/>
+    <junction id="r_e" type="priority" x="30.00" y="0.00"/>
+    <junction id="r_s" type="priority" x="0.00" y="-30.00"/>
+    <junction id="r_w" type="priority" x="-30.00" y="0.00"/>
+
+</net>'''
+        
+        output_net = SUMO_NETWORKS_DIR / f"{output_prefix}.net.xml"
+        with open(output_net, 'w') as f:
+            f.write(network_xml)
+        
+        self.network_path = str(output_net)
+        print(f"Created minimal network: {output_net}")
+        return str(output_net)
+    
+    def create_route_file(
+        self,
+        vehicle_1_route: List[str],
+        vehicle_2_route: List[str],
+        vehicle_1_speed: float = 50,
+        vehicle_2_speed: float = 50,
+        output_prefix: str = "routes"
+    ) -> str:
+        """
+        Create a SUMO route file for two vehicles.
+        
+        Args:
+            vehicle_1_route: List of edge IDs for vehicle 1
+            vehicle_2_route: List of edge IDs for vehicle 2
+            vehicle_1_speed: Speed of vehicle 1 in km/h
+            vehicle_2_speed: Speed of vehicle 2 in km/h
+            output_prefix: Prefix for output file
+        
+        Returns:
+            Path to route file
+        """
+        # Convert km/h to m/s
+        v1_speed_ms = vehicle_1_speed / 3.6
+        v2_speed_ms = vehicle_2_speed / 3.6
+        
+        routes_xml = f'''<?xml version="1.0" encoding="UTF-8"?>
+<routes xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://sumo.dlr.de/xsd/routes_file.xsd">
+    
+    <!-- Vehicle types -->
+    <vType id="car1" accel="2.6" decel="4.5" sigma="0.5" length="4.5" maxSpeed="{v1_speed_ms}" color="1,0,0"/>
+    <vType id="car2" accel="2.6" decel="4.5" sigma="0.5" length="4.5" maxSpeed="{v2_speed_ms}" color="0,0,1"/>
+    
+    <!-- Routes -->
+    <route id="route1" edges="{' '.join(vehicle_1_route)}"/>
+    <route id="route2" edges="{' '.join(vehicle_2_route)}"/>
+    
+    <!-- Vehicles -->
+    <vehicle id="vehicle_1" type="car1" route="route1" depart="0" departSpeed="{v1_speed_ms}"/>
+    <vehicle id="vehicle_2" type="car2" route="route2" depart="0" departSpeed="{v2_speed_ms}"/>
+    
+</routes>'''
+        
+        routes_path = SUMO_NETWORKS_DIR / f"{output_prefix}.rou.xml"
+        with open(routes_path, 'w') as f:
+            f.write(routes_xml)
+        
+        print(f"Routes file created: {routes_path}")
+        return str(routes_path)
+    
+    def create_config_file(
+        self,
+        network_file: str,
+        route_file: str,
+        output_prefix: str = "simulation"
+    ) -> str:
+        """
+        Create a SUMO configuration file.
+        
+        Args:
+            network_file: Path to network file
+            route_file: Path to route file
+            output_prefix: Prefix for output files
+        
+        Returns:
+            Path to configuration file
+        """
+        config_xml = f'''<?xml version="1.0" encoding="UTF-8"?>
+<configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://sumo.dlr.de/xsd/sumoConfiguration.xsd">
+
+    <input>
+        <net-file value="{network_file}"/>
+        <route-files value="{route_file}"/>
+    </input>
+
+    <time>
+        <begin value="0"/>
+        <end value="{SUMO_CONFIG['simulation_duration']}"/>
+        <step-length value="{SUMO_CONFIG['step_length']}"/>
+    </time>
+
+    <output>
+        <tripinfo-output value="{SUMO_OUTPUT_DIR}/{output_prefix}_tripinfo.xml"/>
+        <collision-output value="{SUMO_OUTPUT_DIR}/{output_prefix}_collisions.xml"/>
+    </output>
+
+    <processing>
+        <collision.action value="{SUMO_CONFIG['collision_action']}"/>
+        <collision.check-junctions value="true"/>
+    </processing>
+
+    <random>
+        <seed value="{SUMO_CONFIG['random_seed']}"/>
+    </random>
+
+</configuration>'''
+        
+        config_path = SUMO_NETWORKS_DIR / f"{output_prefix}.sumocfg"
+        with open(config_path, 'w') as f:
+            f.write(config_xml)
+        
+        print(f"Configuration file created: {config_path}")
+        return str(config_path)
+    
+    def run_simulation(
+        self,
+        config_file: str,
+        gui: bool = False
+    ) -> Dict:
+        """
+        Run a SUMO simulation.
+        
+        Args:
+            config_file: Path to SUMO configuration file
+            gui: Whether to run with GUI
+        
+        Returns:
+            Dictionary containing simulation results
+        """
+        if not TRACI_AVAILABLE:
+            print("TraCI not available. Running simulation without real-time control.")
+            return self._run_simulation_batch(config_file)
+        
+        results = {
+            "steps": 0,
+            "collision_detected": False,
+            "collision_time": None,
+            "collision_position": None,
+            "vehicle_1_trajectory": [],
+            "vehicle_2_trajectory": [],
+            "vehicle_1_speeds": [],
+            "vehicle_2_speeds": []
+        }
+        
+        try:
+            # Start SUMO
+            sumo_binary = "sumo-gui" if gui else "sumo"
+            traci.start([sumo_binary, "-c", config_file])
+            
+            step = 0
+            while traci.simulation.getMinExpectedNumber() > 0:
+                traci.simulationStep()
+                
+                # Get vehicle positions
+                if "vehicle_1" in traci.vehicle.getIDList():
+                    pos = traci.vehicle.getPosition("vehicle_1")
+                    speed = traci.vehicle.getSpeed("vehicle_1")
+                    results["vehicle_1_trajectory"].append(pos)
+                    results["vehicle_1_speeds"].append(speed)
+                
+                if "vehicle_2" in traci.vehicle.getIDList():
+                    pos = traci.vehicle.getPosition("vehicle_2")
+                    speed = traci.vehicle.getSpeed("vehicle_2")
+                    results["vehicle_2_trajectory"].append(pos)
+                    results["vehicle_2_speeds"].append(speed)
+                
+                # Check for collisions
+                collisions = traci.simulation.getCollidingVehiclesIDList()
+                if collisions:
+                    results["collision_detected"] = True
+                    results["collision_time"] = step * SUMO_CONFIG["step_length"]
+                    if results["vehicle_1_trajectory"]:
+                        results["collision_position"] = results["vehicle_1_trajectory"][-1]
+                
+                step += 1
+            
+            results["steps"] = step
+            traci.close()
+            
+        except Exception as e:
+            print(f"Simulation error: {e}")
+            if traci.isLoaded():
+                traci.close()
+        
+        return results
+    
+    def _run_simulation_batch(self, config_file: str) -> Dict:
+        """Run simulation in batch mode without TraCI."""
+        try:
+            result = subprocess.run(
+                ["sumo", "-c", config_file],
+                capture_output=True,
+                text=True
+            )
+            
+            return {
+                "steps": SUMO_CONFIG["simulation_duration"] / SUMO_CONFIG["step_length"],
+                "collision_detected": "collision" in result.stdout.lower(),
+                "stdout": result.stdout,
+                "stderr": result.stderr
+            }
+        except FileNotFoundError:
+            print("SUMO not found. Please install SUMO.")
+            return {"error": "SUMO not installed"}
+
+
+def create_simulation_for_scenario(
+    scenario: Dict,
+    vehicle_1: Dict,
+    vehicle_2: Dict,
+    scenario_id: int = 1
+) -> Dict:
+    """
+    Create and run a SUMO simulation for a specific accident scenario.
+    
+    Args:
+        scenario: Scenario dictionary from AI analysis
+        vehicle_1: Vehicle 1 data
+        vehicle_2: Vehicle 2 data
+        scenario_id: Unique identifier for this scenario
+    
+    Returns:
+        Simulation results dictionary
+    """
+    simulator = SUMOSimulator()
+    
+    # Create network
+    network_path = simulator.create_simple_network(f"scenario_{scenario_id}")
+    
+    # Map directions to routes
+    direction_routes = {
+        "north": ["in_n", "r_n_e", "r_e_s", "out_s"],
+        "south": ["in_s", "r_s_w", "r_w_n", "out_n"],
+        "east": ["in_e", "r_e_s", "r_s_w", "out_w"],
+        "west": ["in_w", "r_w_n", "r_n_e", "out_e"]
+    }
+    
+    v1_direction = vehicle_1.get("direction", "north")
+    v2_direction = vehicle_2.get("direction", "east")
+    
+    v1_route = direction_routes.get(v1_direction, direction_routes["north"])
+    v2_route = direction_routes.get(v2_direction, direction_routes["east"])
+    
+    # Create route file
+    route_path = simulator.create_route_file(
+        vehicle_1_route=v1_route,
+        vehicle_2_route=v2_route,
+        vehicle_1_speed=vehicle_1.get("speed", 50),
+        vehicle_2_speed=vehicle_2.get("speed", 50),
+        output_prefix=f"scenario_{scenario_id}"
+    )
+    
+    # Create config file
+    config_path = simulator.create_config_file(
+        network_file=network_path,
+        route_file=route_path,
+        output_prefix=f"scenario_{scenario_id}"
+    )
+    
+    # Run simulation
+    results = simulator.run_simulation(config_path, gui=False)
+    
+    return results
+
+
+if __name__ == "__main__":
+    # Test simulation setup
+    print("Testing SUMO simulation setup...")
+    
+    simulator = SUMOSimulator()
+    
+    # Create a test network
+    network = simulator.create_simple_network("test_network")
+    print(f"Network created: {network}")
+    
+    # Create test routes
+    routes = simulator.create_route_file(
+        vehicle_1_route=["in_n", "r_n_e", "r_e_s", "out_s"],
+        vehicle_2_route=["in_e", "r_e_s", "r_s_w", "out_w"],
+        vehicle_1_speed=50,
+        vehicle_2_speed=60,
+        output_prefix="test"
+    )
+    
+    # Create config
+    config = simulator.create_config_file(network, routes, "test")
+    
+    print("\nSUMO setup complete!")
+    print(f"Network: {network}")
+    print(f"Routes: {routes}")
+    print(f"Config: {config}")

vehicle_input.py

@@ -0,0 +1,196 @@
+"""
+Vehicle Input Component
+=======================
+Handles vehicle data input forms.
+"""
+
+import streamlit as st
+from config import VEHICLE_TYPES, SPEED_RANGE
+
+
+def render_vehicle_input(vehicle_id: int):
+    """
+    Render the vehicle input form.
+    
+    Args:
+        vehicle_id: 1 or 2 to determine which vehicle
+    """
+    vehicle_key = f'vehicle_{vehicle_id}'
+    color = "#FF4B4B" if vehicle_id == 1 else "#4B7BFF"
+    
+    st.markdown(f"""
+    <div style="
+        background: rgba(255, 255, 255, 0.08);
+        border: 2px solid {color};
+        border-radius: 12px;
+        padding: 1.2rem;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+    ">
+        <h3 style="color: {color}; margin: 0; font-weight: 700;">🚗 Vehicle {vehicle_id} Details</h3>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    st.markdown("")
+    
+    # Vehicle type
+    vehicle_type = st.selectbox(
+        "Vehicle Type",
+        options=list(VEHICLE_TYPES.keys()),
+        format_func=lambda x: VEHICLE_TYPES[x]['name'],
+        index=list(VEHICLE_TYPES.keys()).index(st.session_state[vehicle_key]['type']),
+        key=f"type_{vehicle_id}"
+    )
+    st.session_state[vehicle_key]['type'] = vehicle_type
+    
+    # Show vehicle specs
+    specs = VEHICLE_TYPES[vehicle_type]
+    with st.expander("📋 Vehicle Specifications"):
+        col1, col2 = st.columns(2)
+        with col1:
+            st.write(f"**Length:** {specs['length']} m")
+            st.write(f"**Width:** {specs['width']} m")
+        with col2:
+            st.write(f"**Max Speed:** {specs['max_speed']} km/h")
+            st.write(f"**Accel:** {specs['acceleration']} m/s²")
+    
+    # Speed at time of accident
+    speed = st.slider(
+        "Approximate Speed (km/h)",
+        min_value=SPEED_RANGE['min'],
+        max_value=min(SPEED_RANGE['max'], specs['max_speed']),
+        value=st.session_state[vehicle_key]['speed'],
+        step=5,
+        key=f"speed_{vehicle_id}"
+    )
+    st.session_state[vehicle_key]['speed'] = speed
+    
+    # Speed category indicator
+    if speed < 30:
+        st.success("🐢 Low speed")
+    elif speed < 60:
+        st.info("🚗 Normal speed")
+    elif speed < 100:
+        st.warning("🏎️ High speed")
+    else:
+        st.error("⚠️ Very high speed")
+    
+    # Direction of travel
+    direction = st.selectbox(
+        "Direction of Travel",
+        options=['north', 'south', 'east', 'west', 'northeast', 'northwest', 'southeast', 'southwest'],
+        index=['north', 'south', 'east', 'west', 'northeast', 'northwest', 'southeast', 'southwest'].index(
+            st.session_state[vehicle_key]['direction']
+        ),
+        key=f"direction_{vehicle_id}"
+    )
+    st.session_state[vehicle_key]['direction'] = direction
+    
+    # Direction indicator
+    direction_arrows = {
+        'north': '⬆️', 'south': '⬇️', 'east': '➡️', 'west': '⬅️',
+        'northeast': '↗️', 'northwest': '↖️', 'southeast': '↘️', 'southwest': '↙️'
+    }
+    st.write(f"Direction: {direction_arrows.get(direction, '➡️')} {direction.title()}")
+    
+    # Initial action
+    action = st.selectbox(
+        "Action Before Accident",
+        options=[
+            'going_straight',
+            'turning_left',
+            'turning_right',
+            'changing_lane_left',
+            'changing_lane_right',
+            'entering_roundabout',
+            'exiting_roundabout',
+            'slowing_down',
+            'accelerating',
+            'stopped'
+        ],
+        format_func=lambda x: x.replace('_', ' ').title(),
+        key=f"action_{vehicle_id}"
+    )
+    st.session_state[vehicle_key]['action'] = action
+    
+    # Driver's description
+    description = st.text_area(
+        "Driver's Description of Events",
+        value=st.session_state[vehicle_key].get('description', ''),
+        placeholder=f"What did Vehicle {vehicle_id}'s driver say happened?",
+        height=100,
+        key=f"description_{vehicle_id}"
+    )
+    st.session_state[vehicle_key]['description'] = description
+    
+    # Additional factors
+    st.markdown("**Additional Factors**")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        braking = st.checkbox(
+            "Was braking",
+            key=f"braking_{vehicle_id}"
+        )
+        st.session_state[vehicle_key]['braking'] = braking
+        
+        signaling = st.checkbox(
+            "Was signaling",
+            key=f"signaling_{vehicle_id}"
+        )
+        st.session_state[vehicle_key]['signaling'] = signaling
+    
+    with col2:
+        lights_on = st.checkbox(
+            "Lights on",
+            value=True,
+            key=f"lights_{vehicle_id}"
+        )
+        st.session_state[vehicle_key]['lights_on'] = lights_on
+        
+        horn_used = st.checkbox(
+            "Horn used",
+            key=f"horn_{vehicle_id}"
+        )
+        st.session_state[vehicle_key]['horn_used'] = horn_used
+    
+    # Path status
+    st.markdown("---")
+    st.markdown("**Path Status**")
+    
+    path = st.session_state[vehicle_key].get('path', [])
+    if path and len(path) >= 2:
+        st.success(f"✅ Path defined with {len(path)} points")
+    else:
+        st.warning("⚠️ Please draw the vehicle's path on the map")
+
+
+def render_vehicle_summary(vehicle_id: int):
+    """
+    Render a summary of vehicle data.
+    
+    Args:
+        vehicle_id: 1 or 2
+    """
+    vehicle_key = f'vehicle_{vehicle_id}'
+    vehicle = st.session_state[vehicle_key]
+    color = "#FF4B4B" if vehicle_id == 1 else "#4B7BFF"
+    
+    st.markdown(f"""
+    <div style="
+        background: rgba(255, 255, 255, 0.08);
+        backdrop-filter: blur(10px);
+        border: 2px solid {color};
+        border-radius: 12px;
+        padding: 1.2rem;
+        margin: 0.5rem 0;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+    ">
+        <h4 style="color: {color}; margin: 0 0 0.8rem 0; font-weight: 700;">🚗 Vehicle {vehicle_id}</h4>
+        <p style="margin: 0.25rem 0; color: white;"><b>Type:</b> {VEHICLE_TYPES[vehicle['type']]['name']}</p>
+        <p style="margin: 0.25rem 0; color: white;"><b>Speed:</b> {vehicle['speed']} km/h</p>
+        <p style="margin: 0.25rem 0; color: white;"><b>Direction:</b> {vehicle['direction'].title()}</p>
+        <p style="margin: 0.25rem 0; color: white;"><b>Action:</b> {vehicle.get('action', 'N/A').replace('_', ' ').title()}</p>
+        <p style="margin: 0.25rem 0; color: white;"><b>Path Points:</b> {len(vehicle.get('path', []))}</p>
+    </div>
+    """, unsafe_allow_html=True)

video_generator.py

@@ -0,0 +1,919 @@
+"""
+Professional Video Generator for Accident Scenarios
+====================================================
+Generates high-quality animated visualizations of accident scenarios
+with realistic car graphics, detailed roads, and smooth animations.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import matplotlib.patches as patches
+from matplotlib.patches import Rectangle, Circle, FancyBboxPatch, Polygon, Wedge, Arc
+from matplotlib.collections import PatchCollection
+from matplotlib.transforms import Affine2D
+import matplotlib.patheffects as path_effects
+from pathlib import Path
+import json
+
+# Project paths
+OUTPUT_DIR = Path(__file__).parent.parent / "output" / "visualizations"
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+
+class Car:
+    """Professional car visualization with realistic shape."""
+    
+    def __init__(self, ax, x, y, angle=0, color='#e74c3c', label='', scale=1.0):
+        self.ax = ax
+        self.x = x
+        self.y = y
+        self.angle = angle  # degrees, 0 = facing right
+        self.color = color
+        self.label = label
+        self.scale = scale
+        self.patches = []
+        self.draw()
+    
+    def draw(self):
+        """Draw the car with all its components."""
+        # Clear previous patches
+        for p in self.patches:
+            p.remove()
+        self.patches = []
+        
+        # Car dimensions (scaled)
+        length = 4.5 * self.scale
+        width = 2.0 * self.scale
+        
+        # Create car body shape (rounded rectangle with hood and trunk)
+        # Main body
+        body = FancyBboxPatch(
+            (self.x - length/2, self.y - width/2),
+            length, width,
+            boxstyle="round,pad=0,rounding_size=0.3",
+            facecolor=self.color,
+            edgecolor='#2c3e50',
+            linewidth=2,
+            zorder=10
+        )
+        
+        # Windshield area (darker)
+        windshield_length = length * 0.35
+        windshield = FancyBboxPatch(
+            (self.x - length/2 + length*0.55, self.y - width/2 + width*0.1),
+            windshield_length, width * 0.8,
+            boxstyle="round,pad=0,rounding_size=0.2",
+            facecolor='#34495e',
+            edgecolor='#2c3e50',
+            linewidth=1,
+            zorder=11
+        )
+        
+        # Front windshield highlight
+        highlight = FancyBboxPatch(
+            (self.x - length/2 + length*0.58, self.y - width/2 + width*0.15),
+            windshield_length * 0.3, width * 0.7,
+            boxstyle="round,pad=0,rounding_size=0.1",
+            facecolor='#5d6d7e',
+            edgecolor='none',
+            alpha=0.5,
+            zorder=12
+        )
+        
+        # Headlights
+        headlight_y_offset = width * 0.3
+        headlight1 = Circle(
+            (self.x + length/2 - 0.3*self.scale, self.y + headlight_y_offset),
+            0.25 * self.scale,
+            facecolor='#f1c40f',
+            edgecolor='#f39c12',
+            linewidth=1,
+            zorder=12
+        )
+        headlight2 = Circle(
+            (self.x + length/2 - 0.3*self.scale, self.y - headlight_y_offset),
+            0.25 * self.scale,
+            facecolor='#f1c40f',
+            edgecolor='#f39c12',
+            linewidth=1,
+            zorder=12
+        )
+        
+        # Taillights
+        taillight1 = Rectangle(
+            (self.x - length/2, self.y + width/2 - 0.5*self.scale),
+            0.3 * self.scale, 0.35 * self.scale,
+            facecolor='#c0392b',
+            edgecolor='#922b21',
+            linewidth=1,
+            zorder=12
+        )
+        taillight2 = Rectangle(
+            (self.x - length/2, self.y - width/2 + 0.15*self.scale),
+            0.3 * self.scale, 0.35 * self.scale,
+            facecolor='#c0392b',
+            edgecolor='#922b21',
+            linewidth=1,
+            zorder=12
+        )
+        
+        # Wheels
+        wheel_size = 0.5 * self.scale
+        wheel_positions = [
+            (self.x - length/2 + length*0.2, self.y + width/2 - 0.1*self.scale),
+            (self.x - length/2 + length*0.2, self.y - width/2 + 0.1*self.scale),
+            (self.x + length/2 - length*0.2, self.y + width/2 - 0.1*self.scale),
+            (self.x + length/2 - length*0.2, self.y - width/2 + 0.1*self.scale),
+        ]
+        
+        wheels = []
+        for wx, wy in wheel_positions:
+            # Tire
+            tire = Circle(
+                (wx, wy), wheel_size,
+                facecolor='#2c3e50',
+                edgecolor='#1a252f',
+                linewidth=1.5,
+                zorder=9
+            )
+            # Hubcap
+            hubcap = Circle(
+                (wx, wy), wheel_size * 0.6,
+                facecolor='#7f8c8d',
+                edgecolor='#95a5a6',
+                linewidth=1,
+                zorder=9
+            )
+            wheels.extend([tire, hubcap])
+        
+        # Add shadow under car
+        shadow = FancyBboxPatch(
+            (self.x - length/2 + 0.2, self.y - width/2 - 0.3),
+            length, width,
+            boxstyle="round,pad=0,rounding_size=0.3",
+            facecolor='black',
+            edgecolor='none',
+            alpha=0.2,
+            zorder=5
+        )
+        
+        # Store all patches
+        all_patches = [shadow, body, windshield, highlight, 
+                       headlight1, headlight2, taillight1, taillight2] + wheels
+        
+        # Apply rotation transform
+        transform = Affine2D().rotate_deg_around(self.x, self.y, self.angle) + self.ax.transData
+        
+        for patch in all_patches:
+            patch.set_transform(transform)
+            self.ax.add_patch(patch)
+            self.patches.append(patch)
+    
+    def set_position(self, x, y, angle=None):
+        """Update car position and optionally angle."""
+        self.x = x
+        self.y = y
+        if angle is not None:
+            self.angle = angle
+        self.draw()
+    
+    def remove(self):
+        """Remove all patches."""
+        for p in self.patches:
+            try:
+                p.remove()
+            except:
+                pass
+        self.patches = []
+
+
+class ProfessionalAccidentVideoGenerator:
+    """Generate professional animated videos of accident scenarios."""
+    
+    def __init__(self, width=800, height=600, dpi=100):
+        self.width = width
+        self.height = height
+        self.dpi = dpi
+        self.fig_width = width / dpi
+        self.fig_height = height / dpi
+        
+        # Color scheme
+        self.colors = {
+            'background': '#1a1a2e',
+            'road': '#4a4a5a',
+            'road_edge': '#6a6a7a',
+            'lane_marking': '#ffffff',
+            'center_line': '#f1c40f',
+            'grass': '#2d5a27',
+            'sidewalk': '#95a5a6',
+            'car1': '#e74c3c',  # Red
+            'car2': '#3498db',  # Blue
+            'impact': '#f39c12',
+            'text': '#ecf0f1'
+        }
+    
+    def _draw_road_texture(self, ax, road_rect, orientation='horizontal'):
+        """Add realistic road texture and markings."""
+        x, y, w, h = road_rect
+        
+        # Road base with gradient effect
+        road = FancyBboxPatch(
+            (x, y), w, h,
+            boxstyle="round,pad=0,rounding_size=0.5",
+            facecolor=self.colors['road'],
+            edgecolor=self.colors['road_edge'],
+            linewidth=3,
+            zorder=1
+        )
+        ax.add_patch(road)
+        
+        # Add road edge lines
+        if orientation == 'horizontal':
+            # Top edge
+            ax.plot([x, x + w], [y + h, y + h], color='#ffffff', linewidth=2, zorder=2)
+            # Bottom edge
+            ax.plot([x, x + w], [y, y], color='#ffffff', linewidth=2, zorder=2)
+        else:
+            # Left edge
+            ax.plot([x, x], [y, y + h], color='#ffffff', linewidth=2, zorder=2)
+            # Right edge
+            ax.plot([x + w, x + w], [y, y + h], color='#ffffff', linewidth=2, zorder=2)
+    
+    def _draw_lane_markings(self, ax, start, end, center_y, lane_width, is_two_way=False):
+        """Draw dashed lane markings."""
+        dash_length = 3
+        gap_length = 2
+        
+        if is_two_way:
+            # Center double yellow line
+            ax.plot([start, end], [center_y + 0.3, center_y + 0.3], 
+                   color=self.colors['center_line'], linewidth=2.5, zorder=3)
+            ax.plot([start, end], [center_y - 0.3, center_y - 0.3], 
+                   color=self.colors['center_line'], linewidth=2.5, zorder=3)
+        
+        # Dashed white lines for lanes
+        x = start
+        while x < end:
+            ax.plot([x, min(x + dash_length, end)], [center_y + lane_width, center_y + lane_width],
+                   color=self.colors['lane_marking'], linewidth=2, zorder=3, alpha=0.8)
+            ax.plot([x, min(x + dash_length, end)], [center_y - lane_width, center_y - lane_width],
+                   color=self.colors['lane_marking'], linewidth=2, zorder=3, alpha=0.8)
+            x += dash_length + gap_length
+    
+    def _add_impact_effect(self, ax, x, y, intensity=1.0):
+        """Add explosion/impact effect."""
+        # Multiple circles for burst effect
+        for i in range(5):
+            radius = (2 + i * 0.8) * intensity
+            alpha = 0.8 - i * 0.15
+            color = '#f39c12' if i < 2 else '#e74c3c'
+            impact = Circle(
+                (x, y), radius,
+                facecolor=color,
+                edgecolor='#f1c40f',
+                alpha=alpha,
+                linewidth=2 if i == 0 else 0,
+                zorder=20 - i
+            )
+            ax.add_patch(impact)
+        
+        # Spark lines
+        for angle in range(0, 360, 45):
+            rad = np.radians(angle)
+            length = 4 * intensity
+            ax.plot(
+                [x, x + length * np.cos(rad)],
+                [y, y + length * np.sin(rad)],
+                color='#f1c40f', linewidth=2, alpha=0.8, zorder=21
+            )
+    
+    def generate_rear_end_collision(self, output_path=None):
+        """Generate professional rear-end collision animation."""
+        
+        if output_path is None:
+            output_path = OUTPUT_DIR / "rear_end_collision.gif"
+        
+        fig, ax = plt.subplots(figsize=(self.fig_width, self.fig_height), dpi=self.dpi)
+        ax.set_xlim(0, 100)
+        ax.set_ylim(0, 75)
+        ax.set_aspect('equal')
+        ax.set_facecolor(self.colors['background'])
+        fig.patch.set_facecolor(self.colors['background'])
+        ax.axis('off')
+        
+        # Draw environment
+        # Grass/ground on sides
+        grass_top = Rectangle((0, 55), 100, 20, facecolor=self.colors['grass'], zorder=0)
+        grass_bottom = Rectangle((0, 0), 100, 20, facecolor=self.colors['grass'], zorder=0)
+        ax.add_patch(grass_top)
+        ax.add_patch(grass_bottom)
+        
+        # Main road
+        self._draw_road_texture(ax, (0, 20, 100, 35), 'horizontal')
+        
+        # Lane markings (single lane road with dashes)
+        for x in np.arange(0, 100, 8):
+            ax.plot([x, x + 4], [37.5, 37.5], color='white', linewidth=2, zorder=3, alpha=0.8)
+        
+        # Add some road details - small dots/texture
+        for _ in range(50):
+            rx, ry = np.random.uniform(5, 95), np.random.uniform(22, 53)
+            dot = Circle((rx, ry), 0.15, facecolor='#3a3a4a', alpha=0.3, zorder=2)
+            ax.add_patch(dot)
+        
+        # Title
+        title = ax.text(50, 70, 'Rear-End Collision Scenario', 
+                       color=self.colors['text'], fontsize=18, ha='center', 
+                       weight='bold', zorder=30)
+        title.set_path_effects([path_effects.withStroke(linewidth=3, foreground='black')])
+        
+        # Subtitle
+        subtitle = ax.text(50, 5, 'Vehicle 1 (Red) approaching Vehicle 2 (Blue) at high speed',
+                          color=self.colors['text'], fontsize=11, ha='center', zorder=30)
+        subtitle.set_path_effects([path_effects.withStroke(linewidth=2, foreground='black')])
+        
+        # Speed indicators
+        speed1_text = ax.text(5, 65, '● Red Vehicle: 120 km/h', color='#e74c3c', fontsize=10, weight='bold', zorder=30)
+        speed2_text = ax.text(5, 60, '● Blue Vehicle: 50 km/h', color='#3498db', fontsize=10, weight='bold', zorder=30)
+        
+        # Animation parameters
+        frames = 80
+        impact_frame = 50
+        
+        # Store car objects
+        car1_data = {'x': 10, 'y': 32, 'angle': 0}
+        car2_data = {'x': 55, 'y': 32, 'angle': 0}
+        
+        # Initial car drawing
+        car1_patches = []
+        car2_patches = []
+        impact_patches = []
+        
+        def draw_car(x, y, angle, color, ax):
+            """Draw a simple but nice car."""
+            patches = []
+            scale = 1.2
+            length = 5 * scale
+            width = 2.2 * scale
+            
+            # Shadow
+            shadow = FancyBboxPatch(
+                (x - length/2 + 0.3, y - width/2 - 0.4),
+                length, width,
+                boxstyle="round,pad=0,rounding_size=0.4",
+                facecolor='black', alpha=0.3, zorder=4
+            )
+            patches.append(shadow)
+            
+            # Main body
+            body = FancyBboxPatch(
+                (x - length/2, y - width/2),
+                length, width,
+                boxstyle="round,pad=0,rounding_size=0.4",
+                facecolor=color, edgecolor='#1a1a2e', linewidth=2, zorder=10
+            )
+            patches.append(body)
+            
+            # Cabin/windshield
+            cabin = FancyBboxPatch(
+                (x - length*0.1, y - width/2 + 0.3),
+                length * 0.35, width - 0.6,
+                boxstyle="round,pad=0,rounding_size=0.2",
+                facecolor='#2c3e50', edgecolor='#1a252f', linewidth=1, zorder=11
+            )
+            patches.append(cabin)
+            
+            # Windshield reflection
+            reflection = FancyBboxPatch(
+                (x - length*0.05, y - width/2 + 0.5),
+                length * 0.15, width - 1.0,
+                boxstyle="round,pad=0,rounding_size=0.1",
+                facecolor='#5d6d7e', alpha=0.4, zorder=12
+            )
+            patches.append(reflection)
+            
+            # Headlights
+            hl1 = Circle((x + length/2 - 0.4, y + width/3), 0.35, 
+                        facecolor='#f5f5f5', edgecolor='#bdc3c7', zorder=12)
+            hl2 = Circle((x + length/2 - 0.4, y - width/3), 0.35,
+                        facecolor='#f5f5f5', edgecolor='#bdc3c7', zorder=12)
+            patches.extend([hl1, hl2])
+            
+            # Taillights
+            tl1 = Rectangle((x - length/2, y + width/3 - 0.2), 0.4, 0.4,
+                           facecolor='#c0392b', edgecolor='#922b21', zorder=12)
+            tl2 = Rectangle((x - length/2, y - width/3 - 0.2), 0.4, 0.4,
+                           facecolor='#c0392b', edgecolor='#922b21', zorder=12)
+            patches.extend([tl1, tl2])
+            
+            # Wheels
+            wheel_positions = [
+                (x - length/2 + length*0.2, y + width/2 + 0.1),
+                (x - length/2 + length*0.2, y - width/2 - 0.1),
+                (x + length/2 - length*0.2, y + width/2 + 0.1),
+                (x + length/2 - length*0.2, y - width/2 - 0.1),
+            ]
+            for wx, wy in wheel_positions:
+                tire = Circle((wx, wy), 0.6, facecolor='#1a1a2e', zorder=8)
+                rim = Circle((wx, wy), 0.35, facecolor='#7f8c8d', zorder=9)
+                patches.extend([tire, rim])
+            
+            # Apply rotation
+            transform = Affine2D().rotate_deg_around(x, y, angle) + ax.transData
+            for p in patches:
+                p.set_transform(transform)
+                ax.add_patch(p)
+            
+            return patches
+        
+        def animate(frame):
+            nonlocal car1_patches, car2_patches, impact_patches
+            
+            # Remove old patches
+            for p in car1_patches + car2_patches + impact_patches:
+                try:
+                    p.remove()
+                except:
+                    pass
+            car1_patches = []
+            car2_patches = []
+            impact_patches = []
+            
+            # Calculate positions
+            if frame < impact_frame:
+                # Car 1 moving fast
+                x1 = 10 + frame * 1.1
+                # Car 2 moving slow
+                x2 = 55 + frame * 0.25
+                angle1 = 0
+                angle2 = 0
+            else:
+                # Post-impact
+                post = frame - impact_frame
+                # Car 1 stops abruptly
+                x1 = 10 + impact_frame * 1.1 + post * 0.1
+                # Car 2 gets pushed
+                x2 = 55 + impact_frame * 0.25 + post * 0.8
+                # Add some rotation from impact
+                angle1 = -post * 0.5
+                angle2 = post * 0.8
+            
+            # Draw cars
+            car1_patches = draw_car(x1, 32, angle1, self.colors['car1'], ax)
+            car2_patches = draw_car(x2, 32, angle2, self.colors['car2'], ax)
+            
+            # Impact effect at collision
+            if impact_frame <= frame < impact_frame + 10:
+                intensity = 1.0 - (frame - impact_frame) * 0.1
+                impact_x = 10 + impact_frame * 1.1 + 3
+                
+                # Explosion circles
+                for i in range(4):
+                    radius = (1.5 + i * 0.6) * intensity
+                    alpha = (0.7 - i * 0.15) * intensity
+                    colors = ['#f39c12', '#e74c3c', '#f1c40f', '#e67e22']
+                    impact = Circle(
+                        (impact_x, 32), radius,
+                        facecolor=colors[i], alpha=alpha, zorder=25 - i
+                    )
+                    ax.add_patch(impact)
+                    impact_patches.append(impact)
+                
+                # Spark lines
+                for angle in range(0, 360, 30):
+                    rad = np.radians(angle + frame * 10)
+                    length = 3 * intensity
+                    line, = ax.plot(
+                        [impact_x, impact_x + length * np.cos(rad)],
+                        [32, 32 + length * np.sin(rad)],
+                        color='#f1c40f', linewidth=2, alpha=intensity, zorder=26
+                    )
+                    # We need to track these too but plot returns Line2D not Patch
+            
+            return car1_patches + car2_patches
+        
+        # Create animation
+        anim = animation.FuncAnimation(fig, animate, frames=frames, interval=60, blit=False)
+        anim.save(str(output_path), writer='pillow', fps=20)
+        plt.close()
+        
+        return str(output_path)
+    
+    def generate_head_on_collision(self, output_path=None):
+        """Generate professional head-on collision animation."""
+        
+        if output_path is None:
+            output_path = OUTPUT_DIR / "head_on_collision.gif"
+        
+        fig, ax = plt.subplots(figsize=(self.fig_width, self.fig_height), dpi=self.dpi)
+        ax.set_xlim(0, 100)
+        ax.set_ylim(0, 75)
+        ax.set_aspect('equal')
+        ax.set_facecolor(self.colors['background'])
+        fig.patch.set_facecolor(self.colors['background'])
+        ax.axis('off')
+        
+        # Environment
+        grass_top = Rectangle((0, 55), 100, 20, facecolor=self.colors['grass'], zorder=0)
+        grass_bottom = Rectangle((0, 0), 100, 20, facecolor=self.colors['grass'], zorder=0)
+        ax.add_patch(grass_top)
+        ax.add_patch(grass_bottom)
+        
+        # Two-lane road
+        self._draw_road_texture(ax, (0, 20, 100, 35), 'horizontal')
+        
+        # Center line (double yellow)
+        ax.plot([0, 100], [37.8, 37.8], color=self.colors['center_line'], linewidth=3, zorder=3)
+        ax.plot([0, 100], [37.2, 37.2], color=self.colors['center_line'], linewidth=3, zorder=3)
+        
+        # Lane markings
+        for x in np.arange(0, 100, 8):
+            ax.plot([x, x + 4], [28, 28], color='white', linewidth=2, zorder=3, alpha=0.7)
+            ax.plot([x, x + 4], [47, 47], color='white', linewidth=2, zorder=3, alpha=0.7)
+        
+        # Title
+        title = ax.text(50, 70, 'Head-On Collision Scenario', 
+                       color=self.colors['text'], fontsize=18, ha='center', 
+                       weight='bold', zorder=30)
+        title.set_path_effects([path_effects.withStroke(linewidth=3, foreground='black')])
+        
+        subtitle = ax.text(50, 5, 'Vehicle 1 (Red) crosses center line, Vehicle 2 (Blue) oncoming',
+                          color=self.colors['text'], fontsize=11, ha='center', zorder=30)
+        subtitle.set_path_effects([path_effects.withStroke(linewidth=2, foreground='black')])
+        
+        # Speed indicators
+        ax.text(5, 65, '● Red Vehicle: 90 km/h (drifting)', color='#e74c3c', fontsize=10, weight='bold', zorder=30)
+        ax.text(5, 60, '● Blue Vehicle: 80 km/h', color='#3498db', fontsize=10, weight='bold', zorder=30)
+        
+        frames = 80
+        impact_frame = 45
+        
+        car1_patches = []
+        car2_patches = []
+        impact_patches = []
+        
+        def draw_car(x, y, angle, color, ax):
+            """Draw a car."""
+            patches = []
+            scale = 1.2
+            length = 5 * scale
+            width = 2.2 * scale
+            
+            shadow = FancyBboxPatch(
+                (x - length/2 + 0.3, y - width/2 - 0.4),
+                length, width,
+                boxstyle="round,pad=0,rounding_size=0.4",
+                facecolor='black', alpha=0.3, zorder=4
+            )
+            patches.append(shadow)
+            
+            body = FancyBboxPatch(
+                (x - length/2, y - width/2),
+                length, width,
+                boxstyle="round,pad=0,rounding_size=0.4",
+                facecolor=color, edgecolor='#1a1a2e', linewidth=2, zorder=10
+            )
+            patches.append(body)
+            
+            cabin = FancyBboxPatch(
+                (x - length*0.1, y - width/2 + 0.3),
+                length * 0.35, width - 0.6,
+                boxstyle="round,pad=0,rounding_size=0.2",
+                facecolor='#2c3e50', edgecolor='#1a252f', linewidth=1, zorder=11
+            )
+            patches.append(cabin)
+            
+            # Headlights
+            hl1 = Circle((x + length/2 - 0.4, y + width/3), 0.35, 
+                        facecolor='#f5f5f5', edgecolor='#bdc3c7', zorder=12)
+            hl2 = Circle((x + length/2 - 0.4, y - width/3), 0.35,
+                        facecolor='#f5f5f5', edgecolor='#bdc3c7', zorder=12)
+            patches.extend([hl1, hl2])
+            
+            # Taillights
+            tl1 = Rectangle((x - length/2, y + width/3 - 0.2), 0.4, 0.4,
+                           facecolor='#c0392b', zorder=12)
+            tl2 = Rectangle((x - length/2, y - width/3 - 0.2), 0.4, 0.4,
+                           facecolor='#c0392b', zorder=12)
+            patches.extend([tl1, tl2])
+            
+            # Wheels
+            wheel_positions = [
+                (x - length/2 + length*0.2, y + width/2 + 0.1),
+                (x - length/2 + length*0.2, y - width/2 - 0.1),
+                (x + length/2 - length*0.2, y + width/2 + 0.1),
+                (x + length/2 - length*0.2, y - width/2 - 0.1),
+            ]
+            for wx, wy in wheel_positions:
+                tire = Circle((wx, wy), 0.6, facecolor='#1a1a2e', zorder=8)
+                rim = Circle((wx, wy), 0.35, facecolor='#7f8c8d', zorder=9)
+                patches.extend([tire, rim])
+            
+            transform = Affine2D().rotate_deg_around(x, y, angle) + ax.transData
+            for p in patches:
+                p.set_transform(transform)
+                ax.add_patch(p)
+            
+            return patches
+        
+        def animate(frame):
+            nonlocal car1_patches, car2_patches, impact_patches
+            
+            for p in car1_patches + car2_patches + impact_patches:
+                try:
+                    p.remove()
+                except:
+                    pass
+            car1_patches = []
+            car2_patches = []
+            impact_patches = []
+            
+            if frame < impact_frame:
+                # Car 1 drifting into opposite lane
+                x1 = 10 + frame * 0.9
+                y1 = 28 + frame * 0.2  # Drifting up
+                angle1 = frame * 0.3
+                
+                # Car 2 coming from right
+                x2 = 90 - frame * 0.85
+                y2 = 47
+                angle2 = 180
+            else:
+                post = frame - impact_frame
+                # Both cars stop and spin
+                x1 = 10 + impact_frame * 0.9 - post * 0.3
+                y1 = 28 + impact_frame * 0.2 - post * 0.2
+                angle1 = impact_frame * 0.3 + post * 4
+                
+                x2 = 90 - impact_frame * 0.85 + post * 0.3
+                y2 = 47 + post * 0.2
+                angle2 = 180 - post * 3
+            
+            car1_patches = draw_car(x1, y1, angle1, self.colors['car1'], ax)
+            car2_patches = draw_car(x2, y2, angle2, self.colors['car2'], ax)
+            
+            # Impact effect
+            if impact_frame <= frame < impact_frame + 12:
+                intensity = 1.0 - (frame - impact_frame) * 0.08
+                impact_x = 50
+                impact_y = 40
+                
+                for i in range(5):
+                    radius = (2 + i * 0.8) * intensity
+                    alpha = (0.8 - i * 0.15) * intensity
+                    colors = ['#ffffff', '#f39c12', '#e74c3c', '#f1c40f', '#e67e22']
+                    impact = Circle(
+                        (impact_x, impact_y), radius,
+                        facecolor=colors[i], alpha=alpha, zorder=25 - i
+                    )
+                    ax.add_patch(impact)
+                    impact_patches.append(impact)
+            
+            return car1_patches + car2_patches
+        
+        anim = animation.FuncAnimation(fig, animate, frames=frames, interval=60, blit=False)
+        anim.save(str(output_path), writer='pillow', fps=20)
+        plt.close()
+        
+        return str(output_path)
+    
+    def generate_side_impact_collision(self, output_path=None):
+        """Generate professional side impact collision animation."""
+        
+        if output_path is None:
+            output_path = OUTPUT_DIR / "side_impact_collision.gif"
+        
+        fig, ax = plt.subplots(figsize=(self.fig_width, self.fig_height), dpi=self.dpi)
+        ax.set_xlim(0, 100)
+        ax.set_ylim(0, 100)
+        ax.set_aspect('equal')
+        ax.set_facecolor(self.colors['background'])
+        fig.patch.set_facecolor(self.colors['background'])
+        ax.axis('off')
+        
+        # Intersection - draw grass first in corners
+        # Top-left grass
+        ax.add_patch(Rectangle((0, 60), 35, 40, facecolor=self.colors['grass'], zorder=0))
+        # Top-right grass
+        ax.add_patch(Rectangle((65, 60), 35, 40, facecolor=self.colors['grass'], zorder=0))
+        # Bottom-left grass
+        ax.add_patch(Rectangle((0, 0), 35, 40, facecolor=self.colors['grass'], zorder=0))
+        # Bottom-right grass
+        ax.add_patch(Rectangle((65, 0), 35, 40, facecolor=self.colors['grass'], zorder=0))
+        
+        # Horizontal road
+        self._draw_road_texture(ax, (0, 40, 100, 20), 'horizontal')
+        
+        # Vertical road
+        self._draw_road_texture(ax, (35, 0, 30, 100), 'vertical')
+        
+        # Intersection center
+        ax.add_patch(Rectangle((35, 40), 30, 20, facecolor=self.colors['road'], zorder=2))
+        
+        # Crosswalk markings
+        for y in [40, 58]:
+            for x in np.arange(37, 63, 3):
+                ax.add_patch(Rectangle((x, y), 2, 2, facecolor='white', alpha=0.8, zorder=3))
+        for x in [35, 63]:
+            for y in np.arange(42, 58, 3):
+                ax.add_patch(Rectangle((x, y), 2, 2, facecolor='white', alpha=0.8, zorder=3))
+        
+        # Lane markings on horizontal road
+        for x in np.arange(0, 35, 6):
+            ax.plot([x, x + 3], [50, 50], color='white', linewidth=2, zorder=3, alpha=0.7)
+        for x in np.arange(65, 100, 6):
+            ax.plot([x, x + 3], [50, 50], color='white', linewidth=2, zorder=3, alpha=0.7)
+        
+        # Lane markings on vertical road
+        for y in np.arange(0, 40, 6):
+            ax.plot([50, 50], [y, y + 3], color='white', linewidth=2, zorder=3, alpha=0.7)
+        for y in np.arange(60, 100, 6):
+            ax.plot([50, 50], [y, y + 3], color='white', linewidth=2, zorder=3, alpha=0.7)
+        
+        # Traffic light poles (simple)
+        for pos in [(33, 38), (67, 62)]:
+            ax.add_patch(Circle(pos, 1.5, facecolor='#2c3e50', zorder=5))
+            ax.add_patch(Circle(pos, 1, facecolor='#e74c3c', zorder=6))  # Red light
+        for pos in [(33, 62), (67, 38)]:
+            ax.add_patch(Circle(pos, 1.5, facecolor='#2c3e50', zorder=5))
+            ax.add_patch(Circle(pos, 1, facecolor='#27ae60', zorder=6))  # Green light
+        
+        # Title
+        title = ax.text(50, 95, 'Side Impact Collision Scenario', 
+                       color=self.colors['text'], fontsize=18, ha='center', 
+                       weight='bold', zorder=30)
+        title.set_path_effects([path_effects.withStroke(linewidth=3, foreground='black')])
+        
+        subtitle = ax.text(50, 5, 'Vehicle 1 (Red) runs red light, Vehicle 2 (Blue) T-boned',
+                          color=self.colors['text'], fontsize=11, ha='center', zorder=30)
+        subtitle.set_path_effects([path_effects.withStroke(linewidth=2, foreground='black')])
+        
+        ax.text(3, 92, '● Red Vehicle: 70 km/h', color='#e74c3c', fontsize=10, weight='bold', zorder=30)
+        ax.text(3, 87, '● Blue Vehicle: 50 km/h', color='#3498db', fontsize=10, weight='bold', zorder=30)
+        
+        frames = 80
+        impact_frame = 40
+        
+        car1_patches = []
+        car2_patches = []
+        impact_patches = []
+        
+        def draw_car(x, y, angle, color, ax):
+            """Draw a car."""
+            patches = []
+            scale = 1.0
+            length = 5 * scale
+            width = 2.2 * scale
+            
+            shadow = FancyBboxPatch(
+                (x - length/2 + 0.3, y - width/2 - 0.4),
+                length, width,
+                boxstyle="round,pad=0,rounding_size=0.4",
+                facecolor='black', alpha=0.3, zorder=4
+            )
+            patches.append(shadow)
+            
+            body = FancyBboxPatch(
+                (x - length/2, y - width/2),
+                length, width,
+                boxstyle="round,pad=0,rounding_size=0.4",
+                facecolor=color, edgecolor='#1a1a2e', linewidth=2, zorder=10
+            )
+            patches.append(body)
+            
+            cabin = FancyBboxPatch(
+                (x - length*0.1, y - width/2 + 0.25),
+                length * 0.35, width - 0.5,
+                boxstyle="round,pad=0,rounding_size=0.2",
+                facecolor='#2c3e50', edgecolor='#1a252f', linewidth=1, zorder=11
+            )
+            patches.append(cabin)
+            
+            # Headlights
+            hl1 = Circle((x + length/2 - 0.35, y + width/3), 0.3, 
+                        facecolor='#f5f5f5', edgecolor='#bdc3c7', zorder=12)
+            hl2 = Circle((x + length/2 - 0.35, y - width/3), 0.3,
+                        facecolor='#f5f5f5', edgecolor='#bdc3c7', zorder=12)
+            patches.extend([hl1, hl2])
+            
+            # Taillights
+            tl1 = Rectangle((x - length/2, y + width/3 - 0.15), 0.35, 0.3,
+                           facecolor='#c0392b', zorder=12)
+            tl2 = Rectangle((x - length/2, y - width/3 - 0.15), 0.35, 0.3,
+                           facecolor='#c0392b', zorder=12)
+            patches.extend([tl1, tl2])
+            
+            # Wheels
+            wheel_positions = [
+                (x - length/2 + length*0.2, y + width/2 + 0.1),
+                (x - length/2 + length*0.2, y - width/2 - 0.1),
+                (x + length/2 - length*0.2, y + width/2 + 0.1),
+                (x + length/2 - length*0.2, y - width/2 - 0.1),
+            ]
+            for wx, wy in wheel_positions:
+                tire = Circle((wx, wy), 0.5, facecolor='#1a1a2e', zorder=8)
+                rim = Circle((wx, wy), 0.3, facecolor='#7f8c8d', zorder=9)
+                patches.extend([tire, rim])
+            
+            transform = Affine2D().rotate_deg_around(x, y, angle) + ax.transData
+            for p in patches:
+                p.set_transform(transform)
+                ax.add_patch(p)
+            
+            return patches
+        
+        def animate(frame):
+            nonlocal car1_patches, car2_patches, impact_patches
+            
+            for p in car1_patches + car2_patches + impact_patches:
+                try:
+                    p.remove()
+                except:
+                    pass
+            car1_patches = []
+            car2_patches = []
+            impact_patches = []
+            
+            if frame < impact_frame:
+                # Car 1 moving right (horizontal)
+                x1 = 10 + frame * 1.1
+                y1 = 45
+                angle1 = 0
+                
+                # Car 2 moving down (vertical)
+                x2 = 55
+                y2 = 85 - frame * 1.0
+                angle2 = -90
+            else:
+                post = frame - impact_frame
+                # Both cars pushed to the right
+                x1 = 10 + impact_frame * 1.1 + post * 0.3
+                y1 = 45 + post * 0.4
+                angle1 = post * 3
+                
+                x2 = 55 + post * 0.5
+                y2 = 85 - impact_frame * 1.0 - post * 0.2
+                angle2 = -90 + post * 5
+            
+            car1_patches = draw_car(x1, y1, angle1, self.colors['car1'], ax)
+            car2_patches = draw_car(x2, y2, angle2, self.colors['car2'], ax)
+            
+            # Impact effect
+            if impact_frame <= frame < impact_frame + 12:
+                intensity = 1.0 - (frame - impact_frame) * 0.08
+                impact_x = 52
+                impact_y = 47
+                
+                for i in range(5):
+                    radius = (1.5 + i * 0.6) * intensity
+                    alpha = (0.8 - i * 0.15) * intensity
+                    colors = ['#ffffff', '#f39c12', '#e74c3c', '#f1c40f', '#e67e22']
+                    impact = Circle(
+                        (impact_x, impact_y), radius,
+                        facecolor=colors[i], alpha=alpha, zorder=25 - i
+                    )
+                    ax.add_patch(impact)
+                    impact_patches.append(impact)
+            
+            return car1_patches + car2_patches
+        
+        anim = animation.FuncAnimation(fig, animate, frames=frames, interval=60, blit=False)
+        anim.save(str(output_path), writer='pillow', fps=20)
+        plt.close()
+        
+        return str(output_path)
+    
+    def generate_all_scenarios(self):
+        """Generate all professional scenario animations."""
+        
+        print("🎬 Generating professional accident scenario animations...")
+        
+        videos = {}
+        
+        print("  ➤ Generating rear-end collision...")
+        videos['rear_end_collision'] = self.generate_rear_end_collision()
+        print(f"    ✓ Saved: {videos['rear_end_collision']}")
+        
+        print("  ➤ Generating head-on collision...")
+        videos['head_on_collision'] = self.generate_head_on_collision()
+        print(f"    ✓ Saved: {videos['head_on_collision']}")
+        
+        print("  ➤ Generating side impact collision...")
+        videos['side_impact'] = self.generate_side_impact_collision()
+        print(f"    ✓ Saved: {videos['side_impact']}")
+        
+        # Save manifest
+        manifest_path = OUTPUT_DIR / "video_manifest.json"
+        with open(manifest_path, 'w') as f:
+            json.dump(videos, f, indent=2)
+        
+        print(f"\n✅ All professional animations generated!")
+        print(f"📁 Location: {OUTPUT_DIR}")
+        
+        return videos
+
+
+if __name__ == "__main__":
+    generator = ProfessionalAccidentVideoGenerator()
+    generator.generate_all_scenarios()

video_generator_old.py

@@ -0,0 +1,320 @@
+"""
+Video Generator for Accident Scenarios
+=======================================
+Generates animated visualizations of accident scenarios.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from matplotlib.patches import Rectangle, Circle, FancyArrow
+from pathlib import Path
+import json
+
+# Project paths
+OUTPUT_DIR = Path(__file__).parent.parent / "output" / "visualizations"
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+
+class AccidentVideoGenerator:
+    """Generate animated videos of accident scenarios."""
+    
+    def __init__(self, width=800, height=600, dpi=100):
+        """
+        Initialize video generator.
+        
+        Args:
+            width: Video width in pixels
+            height: Video height in pixels
+            dpi: Dots per inch for rendering
+        """
+        self.width = width
+        self.height = height
+        self.dpi = dpi
+        self.fig_width = width / dpi
+        self.fig_height = height / dpi
+    
+    def generate_rear_end_collision(self, output_path: str = None):
+        """Generate rear-end collision animation."""
+        
+        if output_path is None:
+            output_path = OUTPUT_DIR / "rear_end_collision.gif"
+        
+        # Create figure
+        fig, ax = plt.subplots(figsize=(self.fig_width, self.fig_height), dpi=self.dpi)
+        
+        # Set up the plot
+        ax.set_xlim(0, 100)
+        ax.set_ylim(0, 100)
+        ax.set_aspect('equal')
+        ax.set_facecolor('#2d3436')
+        fig.patch.set_facecolor('#1e272e')
+        
+        # Draw road
+        road = Rectangle((0, 40), 100, 20, facecolor='#636e72', edgecolor='white', linewidth=2)
+        ax.add_patch(road)
+        
+        # Draw lane markings
+        for i in range(0, 100, 10):
+            ax.plot([i, i+5], [50, 50], 'w--', linewidth=2)
+        
+        # Initialize vehicles
+        vehicle1 = Rectangle((10, 45), 8, 10, facecolor='#e74c3c', edgecolor='white', linewidth=2)
+        vehicle2 = Rectangle((30, 45), 8, 10, facecolor='#3498db', edgecolor='white', linewidth=2)
+        
+        ax.add_patch(vehicle1)
+        ax.add_patch(vehicle2)
+        
+        # Add labels
+        ax.text(50, 95, 'Rear-End Collision Scenario', 
+                color='white', fontsize=16, ha='center', weight='bold')
+        ax.text(50, 5, 'Vehicle 1 (Red) approaching Vehicle 2 (Blue) at high speed',
+                color='white', fontsize=10, ha='center')
+        
+        ax.axis('off')
+        
+        # Animation frames
+        frames = 60
+        impact_frame = 40
+        
+        def animate(frame):
+            # Vehicle 1 moves fast
+            if frame < impact_frame:
+                x1 = 10 + (frame * 1.2)
+            else:
+                # Stop at impact point
+                x1 = 10 + (impact_frame * 1.2)
+            
+            # Vehicle 2 moves slowly
+            if frame < impact_frame:
+                x2 = 30 + (frame * 0.3)
+            else:
+                # Push forward after impact
+                x2 = 30 + (impact_frame * 0.3) + ((frame - impact_frame) * 0.5)
+            
+            vehicle1.set_x(x1)
+            vehicle2.set_x(x2)
+            
+            # Add impact effect
+            if frame == impact_frame:
+                impact = Circle((x1 + 8, 50), 5, color='yellow', alpha=0.6)
+                ax.add_patch(impact)
+            
+            return vehicle1, vehicle2
+        
+        # Create animation
+        anim = animation.FuncAnimation(fig, animate, frames=frames, interval=50, blit=True)
+        
+        # Save
+        anim.save(str(output_path), writer='pillow', fps=20)
+        plt.close()
+        
+        return str(output_path)
+    
+    def generate_side_impact_collision(self, output_path: str = None):
+        """Generate side impact collision animation."""
+        
+        if output_path is None:
+            output_path = OUTPUT_DIR / "side_impact_collision.gif"
+        
+        # Create figure
+        fig, ax = plt.subplots(figsize=(self.fig_width, self.fig_height), dpi=self.dpi)
+        
+        # Set up the plot
+        ax.set_xlim(0, 100)
+        ax.set_ylim(0, 100)
+        ax.set_aspect('equal')
+        ax.set_facecolor('#2d3436')
+        fig.patch.set_facecolor('#1e272e')
+        
+        # Draw intersection
+        # Horizontal road
+        h_road = Rectangle((0, 40), 100, 20, facecolor='#636e72', edgecolor='white', linewidth=2)
+        ax.add_patch(h_road)
+        
+        # Vertical road
+        v_road = Rectangle((40, 0), 20, 100, facecolor='#636e72', edgecolor='white', linewidth=2)
+        ax.add_patch(v_road)
+        
+        # Initialize vehicles
+        vehicle1 = Rectangle((10, 45), 8, 10, facecolor='#e74c3c', edgecolor='white', linewidth=2)
+        vehicle2 = Rectangle((45, 70), 10, 8, facecolor='#3498db', edgecolor='white', linewidth=2)
+        
+        ax.add_patch(vehicle1)
+        ax.add_patch(vehicle2)
+        
+        # Add labels
+        ax.text(50, 95, 'Side Impact Collision Scenario', 
+                color='white', fontsize=16, ha='center', weight='bold')
+        ax.text(50, 5, 'Vehicle 1 (Red) entering intersection, Vehicle 2 (Blue) from side',
+                color='white', fontsize=10, ha='center')
+        
+        ax.axis('off')
+        
+        # Animation frames
+        frames = 60
+        impact_frame = 35
+        
+        def animate(frame):
+            # Vehicle 1 moves horizontally
+            if frame < impact_frame:
+                x1 = 10 + (frame * 1.0)
+            else:
+                # Stop at impact
+                x1 = 10 + (impact_frame * 1.0)
+                # Slight shift from impact
+                x1 += (frame - impact_frame) * 0.2
+            
+            # Vehicle 2 moves vertically
+            if frame < impact_frame:
+                y2 = 70 - (frame * 0.8)
+            else:
+                # Stop at impact
+                y2 = 70 - (impact_frame * 0.8)
+                # Slight shift from impact
+                y2 += (frame - impact_frame) * 0.2
+            
+            vehicle1.set_x(x1)
+            vehicle2.set_y(y2)
+            
+            # Add impact effect
+            if frame == impact_frame:
+                impact = Circle((x1 + 4, 50), 6, color='yellow', alpha=0.6)
+                ax.add_patch(impact)
+            
+            return vehicle1, vehicle2
+        
+        # Create animation
+        anim = animation.FuncAnimation(fig, animate, frames=frames, interval=50, blit=True)
+        
+        # Save
+        anim.save(str(output_path), writer='pillow', fps=20)
+        plt.close()
+        
+        return str(output_path)
+    
+    def generate_head_on_collision(self, output_path: str = None):
+        """Generate head-on collision animation."""
+        
+        if output_path is None:
+            output_path = OUTPUT_DIR / "head_on_collision.gif"
+        
+        # Create figure
+        fig, ax = plt.subplots(figsize=(self.fig_width, self.fig_height), dpi=self.dpi)
+        
+        # Set up the plot
+        ax.set_xlim(0, 100)
+        ax.set_ylim(0, 100)
+        ax.set_aspect('equal')
+        ax.set_facecolor('#2d3436')
+        fig.patch.set_facecolor('#1e272e')
+        
+        # Draw road (two-way)
+        road = Rectangle((0, 40), 100, 20, facecolor='#636e72', edgecolor='white', linewidth=2)
+        ax.add_patch(road)
+        
+        # Draw center line (yellow)
+        ax.plot([0, 100], [50, 50], 'y-', linewidth=3)
+        
+        # Draw lane markings
+        for i in range(0, 100, 10):
+            ax.plot([i, i+5], [45, 45], 'w--', linewidth=1)
+            ax.plot([i, i+5], [55, 55], 'w--', linewidth=1)
+        
+        # Initialize vehicles
+        vehicle1 = Rectangle((15, 45), 8, 10, facecolor='#e74c3c', edgecolor='white', linewidth=2)
+        vehicle2 = Rectangle((75, 51), 8, 10, facecolor='#3498db', edgecolor='white', linewidth=2)
+        
+        ax.add_patch(vehicle1)
+        ax.add_patch(vehicle2)
+        
+        # Add labels
+        ax.text(50, 95, 'Head-On Collision Scenario', 
+                color='white', fontsize=16, ha='center', weight='bold')
+        ax.text(50, 5, 'Vehicle 1 (Red) crosses center line, Vehicle 2 (Blue) oncoming',
+                color='white', fontsize=10, ha='center')
+        
+        ax.axis('off')
+        
+        # Animation frames
+        frames = 60
+        impact_frame = 35
+        
+        def animate(frame):
+            # Vehicle 1 moves right and drifts up
+            if frame < impact_frame:
+                x1 = 15 + (frame * 0.9)
+                y1 = 45 + (frame * 0.15)  # Drifting into opposite lane
+            else:
+                # Stop at impact
+                x1 = 15 + (impact_frame * 0.9)
+                y1 = 45 + (impact_frame * 0.15)
+                # Recoil backward
+                x1 -= (frame - impact_frame) * 0.3
+            
+            # Vehicle 2 moves left
+            if frame < impact_frame:
+                x2 = 75 - (frame * 0.9)
+            else:
+                # Stop at impact
+                x2 = 75 - (impact_frame * 0.9)
+                # Recoil backward
+                x2 += (frame - impact_frame) * 0.3
+            
+            vehicle1.set_x(x1)
+            vehicle1.set_y(y1)
+            vehicle2.set_x(x2)
+            
+            # Add impact effect
+            if frame == impact_frame:
+                impact = Circle((50, 52), 8, color='yellow', alpha=0.6)
+                ax.add_patch(impact)
+            
+            return vehicle1, vehicle2
+        
+        # Create animation
+        anim = animation.FuncAnimation(fig, animate, frames=frames, interval=50, blit=True)
+        
+        # Save
+        anim.save(str(output_path), writer='pillow', fps=20)
+        plt.close()
+        
+        return str(output_path)
+    
+    def generate_all_scenarios(self):
+        """Generate all scenario animations."""
+        
+        print("🎬 Generating accident scenario animations...")
+        
+        videos = {}
+        
+        # Generate rear-end collision
+        print("  ➤ Generating rear-end collision...")
+        videos['rear_end_collision'] = self.generate_rear_end_collision()
+        print(f"    ✓ Saved: {videos['rear_end_collision']}")
+        
+        # Generate side impact
+        print("  ➤ Generating side impact...")
+        videos['side_impact'] = self.generate_side_impact_collision()
+        print(f"    ✓ Saved: {videos['side_impact']}")
+        
+        # Generate head-on collision
+        print("  ➤ Generating head-on collision...")
+        videos['head_on_collision'] = self.generate_head_on_collision()
+        print(f"    ✓ Saved: {videos['head_on_collision']}")
+        
+        # Save manifest
+        manifest_path = OUTPUT_DIR / "video_manifest.json"
+        with open(manifest_path, 'w') as f:
+            json.dump(videos, f, indent=2)
+        
+        print(f"\n✅ All animations generated successfully!")
+        print(f"📁 Location: {OUTPUT_DIR}")
+        
+        return videos
+
+
+if __name__ == "__main__":
+    # Generate all scenario videos
+    generator = AccidentVideoGenerator()
+    generator.generate_all_scenarios()

video_manifest.json

@@ -0,0 +1,5 @@
+{
+  "rear_end_collision": "/home/claude/traffic_project/traffic_accident_analyzer/output/visualizations/rear_end_collision.gif",
+  "head_on_collision": "/home/claude/traffic_project/traffic_accident_analyzer/output/visualizations/head_on_collision.gif",
+  "side_impact": "/home/claude/traffic_project/traffic_accident_analyzer/output/visualizations/side_impact_collision.gif"
+}