Deploy REAL original app

.gitattributes

@@ -1,16 +1,5 @@
-# Git LFS Configuration for CrashLens
-# Large File Storage for model files and media
-# AI Model Files
 *.ckpt filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-# Data Files
 *.npz filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-# Video/Animation Files
 *.gif filter=lfs diff=lfs merge=lfs -text
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-# Documentation
 *.pdf filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -2,32 +2,14 @@ FROM python:3.9-slim
 
 WORKDIR /app
 
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y build-essential curl && rm -rf /var/lib/apt/lists/*
 
-# Copy requirements
 COPY requirements.txt .
-
-# Install Python packages
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy all application files
 COPY . .
-
-# Create output directories
 RUN mkdir -p output/reports logs
 
-# Expose port 7860 for Hugging Face Spaces
 EXPOSE 7860
 
-# Environment variables
-ENV STREAMLIT_SERVER_PORT=7860
-ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
-ENV STREAMLIT_SERVER_HEADLESS=true
-ENV STREAMLIT_BROWSER_GATHER_USAGE_STATS=false
-
-# Run the app
-CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]
+CMD streamlit run app.py --server.port=7860 --server.address=0.0.0.0 --server.headless=true --server.fileWatcherType=none --browser.gatherUsageStats=false

README.md

@@ -0,0 +1,279 @@
+# 🚗 Traffic Accident Reconstruction System
+
+## AI-Powered Analysis using Huawei MindSpore
+
+> **Huawei AI Innovation Challenge 2026**  
+> AI Research Team
+
+---
+
+## 📋 Project Overview
+
+This system is an intelligent traffic accident reconstruction tool that helps traffic authorities understand accidents in a clearer and fairer manner. It reconstructs accidents at their real geographic locations using 2D traffic simulation and AI-powered scenario generation.
+
+### Key Features
+
+- **Real Map Integration**: Uses OpenStreetMap to display actual road layouts
+- **AI Scenario Generation**: MindSpore-powered analysis generates multiple accident scenarios
+- **Probability Analysis**: Each scenario includes probability scores and contributing factors
+- **2D Traffic Simulation**: SUMO integration for realistic accident reconstruction
+- **Comprehensive Reports**: PDF and HTML report generation
+
+---
+
+## 🛠️ Technology Stack
+
+| Component | Technology |
+|-----------|------------|
+| **AI Framework** | Huawei MindSpore |
+| **Web Interface** | Streamlit |
+| **Traffic Simulation** | SUMO |
+| **Map Data** | OpenStreetMap |
+| **Data Processing** | NumPy, Pandas |
+| **Visualization** | Plotly, Folium |
+| **Report Generation** | ReportLab, Jinja2 |
+
+---
+
+## 📁 Project Structure
+
+```
+traffic_accident_analyzer/
+├── app.py                      # Main Streamlit application
+├── config.py                   # Configuration settings
+├── requirements.txt            # Python dependencies
+├── setup.sh                    # Setup script
+├── README.md                   # This file
+│
+├── ui/                         # User interface components
+│   ├── __init__.py
+│   ├── components.py           # Reusable UI components
+│   ├── map_viewer.py           # Map display and path drawing
+│   ├── vehicle_input.py        # Vehicle data input forms
+│   └── results_display.py      # Results visualization
+│
+├── analysis/                   # Analysis modules
+│   ├── __init__.py
+│   ├── scenario_analyzer.py    # AI scenario generation
+│   └── report_generator.py     # Report generation
+│
+├── models/                     # MindSpore models
+│   ├── __init__.py
+│   ├── mindspore_model.py      # MindSpore neural network
+│   └── trained/                # Saved model weights
+│
+├── simulation/                 # SUMO simulation
+│   ├── __init__.py
+│   ├── sumo_interface.py       # SUMO integration
+│   ├── networks/               # SUMO network files
+│   └── output/                 # Simulation outputs
+│
+├── data/                       # Data files
+│   ├── raw/                    # Raw data
+│   ├── processed/              # Processed data
+│   └── osm/                    # OpenStreetMap data
+│
+├── output/                     # Output files
+│   ├── reports/                # Generated reports
+│   └── visualizations/         # Generated visualizations
+│
+└── logs/                       # Application logs
+```
+
+---
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Python 3.8 or higher
+- SUMO (for traffic simulation)
+- Git
+
+### Installation
+
+1. **Clone or download the project**
+   ```bash
+   cd traffic_accident_analyzer
+   ```
+
+2. **Run the setup script**
+   ```bash
+   chmod +x setup.sh
+   ./setup.sh
+   ```
+
+3. **Or install manually**
+   ```bash
+   python3 -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   pip install -r requirements.txt
+   ```
+
+4. **Run the application**
+   ```bash
+   streamlit run app.py
+   ```
+
+5. **Open in browser**
+   - Navigate to `http://localhost:8501`
+
+---
+
+## 📖 How to Use
+
+### Step 1: Select Accident Location
+- Choose a preset location or enter custom coordinates
+- The system displays the real road layout from OpenStreetMap
+
+### Step 2: Enter Vehicle 1 Information
+- Select vehicle type, speed, and direction
+- Draw the vehicle's path on the map
+- Add driver's description
+
+### Step 3: Enter Vehicle 2 Information
+- Repeat for the second vehicle
+- Both paths are displayed together
+
+### Step 4: Run AI Analysis
+- Click "Run AI Analysis" to generate scenarios
+- MindSpore AI processes the data
+
+### Step 5: View Results
+- See multiple generated scenarios with probabilities
+- View detailed metrics and contributing factors
+- Generate PDF or HTML reports
+
+---
+
+## 🎯 System Workflow
+
+```
+┌─────────────────┐
+│  User Input     │
+│  (Location,     │
+│   Vehicles)     │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  OpenStreetMap  │
+│  (Road Layout)  │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  Feature        │
+│  Extraction     │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  MindSpore AI   │
+│  (Scenario      │
+│   Generation)   │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  SUMO           │
+│  (Simulation)   │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  Analysis &     │
+│  Report         │
+└─────────────────┘
+```
+
+---
+
+## 🧠 AI Model Details
+
+### Input Features (24 features)
+- Vehicle speeds and dimensions
+- Travel directions and angles
+- Weather and road conditions
+- Path overlap metrics
+- Action risk factors
+
+### Output
+- 5 most probable accident scenarios
+- Probability scores for each
+- Contributing factors
+- Collision point estimation
+
+### Model Architecture
+- Multi-layer neural network
+- Built with MindSpore framework
+- Trained on synthetic accident data
+
+---
+
+## 📊 Analysis Metrics
+
+| Metric | Weight | Description |
+|--------|--------|-------------|
+| Collision Probability | 35% | Likelihood based on trajectories |
+| Path Overlap | 25% | Degree of path intersection |
+| Speed Differential | 20% | Speed difference at collision |
+| Timing Analysis | 20% | Time gap at conflict point |
+
+---
+
+## 🌍 Case Study Location
+
+**دوار السيف - Seef District Roundabout, Bahrain**
+
+- **City:** Manama, Bahrain
+- **Latitude:** 26.2397
+- **Longitude:** 50.5369
+- **Description:** Major roundabout in the Seef commercial district, near City Centre Bahrain mall
+
+---
+
+## 📄 Report Contents
+
+- Executive Summary
+- Accident Details
+- Vehicle Information
+- AI-Generated Scenarios
+- Probability Analysis
+- Contributing Factors
+- Preliminary Fault Assessment
+- Timeline Reconstruction
+- Recommendations
+
+---
+
+## ⚠️ Disclaimer
+
+This system provides AI-generated analysis for reference purposes only. Final accident determination should be made by qualified traffic authorities based on comprehensive investigation.
+
+---
+
+## 🏆 Competition Information
+
+**Huawei AI Innovation Challenge 2026**
+
+- **Track**: Innovation Track
+- **Theme**: MindSpore AI Applications
+- **Institution**: AI Research Team
+- **Country**: Saudi Arabia
+
+---
+
+## 📧 Contact
+
+For questions or support regarding this project, please contact the project team.
+
+---
+
+## 📜 License
+
+This project is developed for the Huawei AI Innovation Challenge 2026.
+
+---
+
+**Built with ❤️ using Huawei MindSpore**

data/__init__.py

@@ -0,0 +1,87 @@
+"""
+Data Package
+=============
+Data handling, schema definitions, and dataset generation for
+the Traffic Accident Reconstruction System.
+"""
+
+from .schema import (
+    # Enums
+    VehicleType,
+    Direction,
+    VehicleAction,
+    WeatherCondition,
+    RoadCondition,
+    AccidentType,
+    Severity,
+    RoadType,
+    
+    # Data classes
+    Location,
+    Conditions,
+    VehicleData,
+    AccidentDetails,
+    ScenarioMetrics,
+    Scenario,
+    FaultAssessment,
+    TimelineEvent,
+    AccidentRecord,
+    AnalysisResult,
+    
+    # Feature schema
+    FEATURE_SCHEMA,
+    
+    # Validation functions
+    validate_speed,
+    validate_coordinates,
+    validate_path,
+    validate_probability
+)
+
+from .synthetic_dataset_generator import (
+    generate_dataset,
+    generate_single_accident,
+    generate_training_features,
+    save_dataset,
+    print_dataset_statistics
+)
+
+__all__ = [
+    # Enums
+    'VehicleType',
+    'Direction', 
+    'VehicleAction',
+    'WeatherCondition',
+    'RoadCondition',
+    'AccidentType',
+    'Severity',
+    'RoadType',
+    
+    # Data classes
+    'Location',
+    'Conditions',
+    'VehicleData',
+    'AccidentDetails',
+    'ScenarioMetrics',
+    'Scenario',
+    'FaultAssessment',
+    'TimelineEvent',
+    'AccidentRecord',
+    'AnalysisResult',
+    
+    # Feature schema
+    'FEATURE_SCHEMA',
+    
+    # Validation
+    'validate_speed',
+    'validate_coordinates',
+    'validate_path',
+    'validate_probability',
+    
+    # Dataset generation
+    'generate_dataset',
+    'generate_single_accident',
+    'generate_training_features',
+    'save_dataset',
+    'print_dataset_statistics'
+]

data/accident_schema.json

@@ -0,0 +1,49 @@
+{
+  "accident_id": "string",
+  "timestamp": "datetime",
+  "location": {
+    "name": "string",
+    "latitude": "float",
+    "longitude": "float",
+    "road_type": "string"
+  },
+  "conditions": {
+    "weather": "string",
+    "road_condition": "string",
+    "visibility": "float",
+    "lighting": "string"
+  },
+  "vehicle_1": {
+    "type": "string",
+    "speed_kmh": "float",
+    "direction": "string",
+    "direction_angle": "float",
+    "action": "string",
+    "braking": "boolean",
+    "signaling": "boolean",
+    "path": "list[tuple]"
+  },
+  "vehicle_2": {
+    "type": "string",
+    "speed_kmh": "float",
+    "direction": "string",
+    "direction_angle": "float",
+    "action": "string",
+    "braking": "boolean",
+    "signaling": "boolean",
+    "path": "list[tuple]"
+  },
+  "accident_details": {
+    "type": "string",
+    "severity": "string",
+    "collision_angle": "float",
+    "collision_point": "tuple",
+    "contributing_factors": "list[string]",
+    "fault_vehicle": "int"
+  },
+  "outcomes": {
+    "scenario_probability": "float",
+    "damage_estimate": "string",
+    "injuries": "boolean"
+  }
+}

data/osm_extractor.py

@@ -0,0 +1,409 @@
+"""
+OpenStreetMap Data Extractor
+============================
+Downloads and processes real road network data from OpenStreetMap
+for use in accident reconstruction simulation.
+"""
+
+import os
+import json
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional
+
+try:
+    import osmnx as ox
+    OSMNX_AVAILABLE = True
+except ImportError:
+    OSMNX_AVAILABLE = False
+    print("Warning: osmnx not installed. Install with: pip install osmnx")
+
+try:
+    import folium
+    FOLIUM_AVAILABLE = True
+except ImportError:
+    FOLIUM_AVAILABLE = False
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from config import CASE_STUDY_LOCATION, ALTERNATIVE_LOCATIONS, OSM_DATA_DIR
+
+
+def download_road_network(
+    latitude: float,
+    longitude: float,
+    radius: int = 200,
+    network_type: str = "drive",
+    save_path: Optional[str] = None
+) -> Dict:
+    """
+    Download road network from OpenStreetMap.
+    
+    Args:
+        latitude: Center latitude
+        longitude: Center longitude
+        radius: Radius in meters
+        network_type: Type of network ('drive', 'walk', 'bike', 'all')
+        save_path: Optional path to save the network
+    
+    Returns:
+        Dictionary containing network data
+    """
+    if not OSMNX_AVAILABLE:
+        print("osmnx not available. Using fallback data.")
+        return create_fallback_network(latitude, longitude, radius)
+    
+    try:
+        # Configure osmnx
+        ox.settings.use_cache = True
+        ox.settings.log_console = True
+        
+        # Download the road network
+        print(f"Downloading road network for ({latitude}, {longitude})...")
+        G = ox.graph_from_point(
+            (latitude, longitude),
+            dist=radius,
+            network_type=network_type,
+            simplify=True
+        )
+        
+        # Get nodes and edges
+        nodes, edges = ox.graph_to_gdfs(G)
+        
+        # Convert to dictionary format
+        network_data = {
+            "center": {"lat": latitude, "lng": longitude},
+            "radius": radius,
+            "nodes": [],
+            "edges": [],
+            "bounds": {
+                "north": nodes.geometry.y.max(),
+                "south": nodes.geometry.y.min(),
+                "east": nodes.geometry.x.max(),
+                "west": nodes.geometry.x.min()
+            }
+        }
+        
+        # Process nodes
+        for idx, row in nodes.iterrows():
+            network_data["nodes"].append({
+                "id": str(idx),
+                "lat": row.geometry.y,
+                "lng": row.geometry.x
+            })
+        
+        # Process edges
+        for idx, row in edges.iterrows():
+            edge_data = {
+                "from": str(idx[0]),
+                "to": str(idx[1]),
+                "length": row.get("length", 0),
+                "name": row.get("name", "Unknown"),
+                "highway": row.get("highway", "unclassified"),
+                "lanes": row.get("lanes", 1),
+                "maxspeed": row.get("maxspeed", "50")
+            }
+            
+            # Get geometry if available
+            if hasattr(row.geometry, 'coords'):
+                edge_data["geometry"] = list(row.geometry.coords)
+            
+            network_data["edges"].append(edge_data)
+        
+        # Save if path provided
+        if save_path:
+            save_path = Path(save_path)
+            save_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            with open(save_path, 'w') as f:
+                json.dump(network_data, f, indent=2)
+            
+            # Also save as GraphML for SUMO conversion
+            graphml_path = save_path.with_suffix('.graphml')
+            ox.save_graphml(G, graphml_path)
+            
+            print(f"Network saved to {save_path}")
+            print(f"GraphML saved to {graphml_path}")
+        
+        return network_data
+        
+    except Exception as e:
+        print(f"Error downloading network: {e}")
+        return create_fallback_network(latitude, longitude, radius)
+
+
+def create_fallback_network(
+    latitude: float,
+    longitude: float,
+    radius: int = 200
+) -> Dict:
+    """
+    Create a fallback network when OSM download fails.
+    Creates a simple roundabout structure.
+    """
+    import math
+    
+    # Create a simple roundabout with 4 approaches
+    network_data = {
+        "center": {"lat": latitude, "lng": longitude},
+        "radius": radius,
+        "nodes": [],
+        "edges": [],
+        "bounds": {
+            "north": latitude + 0.002,
+            "south": latitude - 0.002,
+            "east": longitude + 0.002,
+            "west": longitude - 0.002
+        }
+    }
+    
+    # Create roundabout nodes (8 points in a circle)
+    roundabout_radius = 0.0003  # Approximately 30 meters
+    num_points = 8
+    
+    for i in range(num_points):
+        angle = (2 * math.pi * i) / num_points
+        lat = latitude + roundabout_radius * math.cos(angle)
+        lng = longitude + roundabout_radius * math.sin(angle)
+        
+        network_data["nodes"].append({
+            "id": f"r{i}",
+            "lat": lat,
+            "lng": lng,
+            "type": "roundabout"
+        })
+    
+    # Create approach nodes (4 directions)
+    approach_distance = 0.001  # Approximately 100 meters
+    approaches = [
+        ("north", latitude + approach_distance, longitude),
+        ("south", latitude - approach_distance, longitude),
+        ("east", latitude, longitude + approach_distance),
+        ("west", latitude, longitude - approach_distance)
+    ]
+    
+    for name, lat, lng in approaches:
+        network_data["nodes"].append({
+            "id": f"a_{name}",
+            "lat": lat,
+            "lng": lng,
+            "type": "approach"
+        })
+    
+    # Create roundabout edges (circular)
+    for i in range(num_points):
+        next_i = (i + 1) % num_points
+        network_data["edges"].append({
+            "from": f"r{i}",
+            "to": f"r{next_i}",
+            "length": 20,
+            "name": "Roundabout",
+            "highway": "primary",
+            "lanes": 2
+        })
+    
+    # Connect approaches to roundabout
+    approach_connections = [
+        ("a_north", "r0", "r6"),
+        ("a_east", "r2", "r0"),
+        ("a_south", "r4", "r2"),
+        ("a_west", "r6", "r4")
+    ]
+    
+    for approach, entry, exit in approach_connections:
+        # Entry edge
+        network_data["edges"].append({
+            "from": approach,
+            "to": entry,
+            "length": 80,
+            "name": "Approach Road",
+            "highway": "primary",
+            "lanes": 2
+        })
+        # Exit edge
+        network_data["edges"].append({
+            "from": exit,
+            "to": approach,
+            "length": 80,
+            "name": "Exit Road",
+            "highway": "primary",
+            "lanes": 2
+        })
+    
+    return network_data
+
+
+def extract_intersection_data(
+    latitude: float,
+    longitude: float,
+    radius: int = 100
+) -> Dict:
+    """
+    Extract intersection-specific data from OSM.
+    """
+    if not OSMNX_AVAILABLE:
+        return create_fallback_intersection(latitude, longitude)
+    
+    try:
+        # Get features around the point
+        tags = {"highway": True}
+        gdf = ox.features_from_point((latitude, longitude), tags, dist=radius)
+        
+        intersection_data = {
+            "center": {"lat": latitude, "lng": longitude},
+            "features": []
+        }
+        
+        for idx, row in gdf.iterrows():
+            feature = {
+                "type": row.get("highway", "unknown"),
+                "name": row.get("name", "Unknown")
+            }
+            if hasattr(row.geometry, 'centroid'):
+                feature["lat"] = row.geometry.centroid.y
+                feature["lng"] = row.geometry.centroid.x
+            
+            intersection_data["features"].append(feature)
+        
+        return intersection_data
+        
+    except Exception as e:
+        print(f"Error extracting intersection: {e}")
+        return create_fallback_intersection(latitude, longitude)
+
+
+def create_fallback_intersection(latitude: float, longitude: float) -> Dict:
+    """Create fallback intersection data."""
+    return {
+        "center": {"lat": latitude, "lng": longitude},
+        "type": "roundabout",
+        "approaches": 4,
+        "lanes": 2,
+        "features": [
+            {"type": "primary", "name": "Main Road North-South"},
+            {"type": "primary", "name": "Main Road East-West"}
+        ]
+    }
+
+
+def create_location_map(
+    location: Dict,
+    network_data: Optional[Dict] = None,
+    save_path: Optional[str] = None
+) -> 'folium.Map':
+    """
+    Create an interactive Folium map for the location.
+    """
+    if not FOLIUM_AVAILABLE:
+        print("Folium not available")
+        return None
+    
+    # Create base map
+    m = folium.Map(
+        location=[location["latitude"], location["longitude"]],
+        zoom_start=17,
+        tiles="OpenStreetMap"
+    )
+    
+    # Add center marker
+    folium.Marker(
+        location=[location["latitude"], location["longitude"]],
+        popup=location.get("name", "Location"),
+        icon=folium.Icon(color="red", icon="info-sign")
+    ).add_to(m)
+    
+    # Add radius circle
+    folium.Circle(
+        location=[location["latitude"], location["longitude"]],
+        radius=location.get("radius_meters", 200),
+        color="blue",
+        fill=True,
+        fill_opacity=0.1
+    ).add_to(m)
+    
+    # Add network data if available
+    if network_data:
+        # Add nodes
+        for node in network_data.get("nodes", []):
+            folium.CircleMarker(
+                location=[node["lat"], node["lng"]],
+                radius=3,
+                color="green",
+                fill=True
+            ).add_to(m)
+        
+        # Add edges
+        for edge in network_data.get("edges", []):
+            if "geometry" in edge:
+                # Use actual geometry
+                coords = [(c[1], c[0]) for c in edge["geometry"]]
+                folium.PolyLine(
+                    locations=coords,
+                    color="gray",
+                    weight=2
+                ).add_to(m)
+    
+    # Save if path provided
+    if save_path:
+        m.save(save_path)
+        print(f"Map saved to {save_path}")
+    
+    return m
+
+
+def download_all_locations():
+    """Download network data for all configured locations."""
+    
+    # Create output directory
+    OSM_DATA_DIR.mkdir(parents=True, exist_ok=True)
+    
+    # Download primary location
+    print("\n" + "="*50)
+    print("Downloading primary location...")
+    print("="*50)
+    
+    primary_data = download_road_network(
+        latitude=CASE_STUDY_LOCATION["latitude"],
+        longitude=CASE_STUDY_LOCATION["longitude"],
+        radius=CASE_STUDY_LOCATION["radius_meters"],
+        save_path=OSM_DATA_DIR / "primary_location.json"
+    )
+    
+    # Create map for primary location
+    create_location_map(
+        CASE_STUDY_LOCATION,
+        primary_data,
+        save_path=str(OSM_DATA_DIR / "primary_location_map.html")
+    )
+    
+    # Download alternative locations
+    for loc_key, loc_data in ALTERNATIVE_LOCATIONS.items():
+        print(f"\n" + "="*50)
+        print(f"Downloading {loc_data['name']}...")
+        print("="*50)
+        
+        network_data = download_road_network(
+            latitude=loc_data["latitude"],
+            longitude=loc_data["longitude"],
+            radius=loc_data["radius_meters"],
+            save_path=OSM_DATA_DIR / f"{loc_key}.json"
+        )
+        
+        create_location_map(
+            {
+                "latitude": loc_data["latitude"],
+                "longitude": loc_data["longitude"],
+                "radius_meters": loc_data["radius_meters"],
+                "name": loc_data["name"]
+            },
+            network_data,
+            save_path=str(OSM_DATA_DIR / f"{loc_key}_map.html")
+        )
+    
+    print("\n" + "="*50)
+    print("All locations downloaded successfully!")
+    print("="*50)
+
+
+if __name__ == "__main__":
+    download_all_locations()

data/processed/synthetic_accidents_features.npz

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

data/processed/synthetic_accidents_training_features.npz

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

data/schema.py

@@ -0,0 +1,416 @@
+"""
+Data Schema Definitions
+=======================
+Defines the structure of data used throughout the Traffic Accident
+Reconstruction System.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Tuple, Optional, Dict, Any
+from enum import Enum
+from datetime import datetime
+
+
+# ============================================================
+# ENUMERATIONS
+# ============================================================
+
+class VehicleType(Enum):
+    """Types of vehicles."""
+    SEDAN = "sedan"
+    SUV = "suv"
+    TRUCK = "truck"
+    MOTORCYCLE = "motorcycle"
+    BUS = "bus"
+
+
+class Direction(Enum):
+    """Cardinal and intercardinal directions."""
+    NORTH = "north"
+    NORTHEAST = "northeast"
+    EAST = "east"
+    SOUTHEAST = "southeast"
+    SOUTH = "south"
+    SOUTHWEST = "southwest"
+    WEST = "west"
+    NORTHWEST = "northwest"
+
+
+class VehicleAction(Enum):
+    """Possible vehicle actions."""
+    GOING_STRAIGHT = "going_straight"
+    TURNING_LEFT = "turning_left"
+    TURNING_RIGHT = "turning_right"
+    ENTERING_ROUNDABOUT = "entering_roundabout"
+    EXITING_ROUNDABOUT = "exiting_roundabout"
+    CHANGING_LANE_LEFT = "changing_lane_left"
+    CHANGING_LANE_RIGHT = "changing_lane_right"
+    SLOWING_DOWN = "slowing_down"
+    ACCELERATING = "accelerating"
+    STOPPED = "stopped"
+
+
+class WeatherCondition(Enum):
+    """Weather conditions."""
+    CLEAR = "clear"
+    CLOUDY = "cloudy"
+    RAINY = "rainy"
+    FOGGY = "foggy"
+    SANDSTORM = "sandstorm"
+
+
+class RoadCondition(Enum):
+    """Road surface conditions."""
+    DRY = "dry"
+    WET = "wet"
+    SANDY = "sandy"
+    OILY = "oily"
+
+
+class AccidentType(Enum):
+    """Types of traffic accidents."""
+    REAR_END_COLLISION = "rear_end_collision"
+    SIDE_IMPACT = "side_impact"
+    HEAD_ON_COLLISION = "head_on_collision"
+    SIDESWIPE = "sideswipe"
+    ROUNDABOUT_ENTRY_COLLISION = "roundabout_entry_collision"
+    LANE_CHANGE_COLLISION = "lane_change_collision"
+    INTERSECTION_COLLISION = "intersection_collision"
+
+
+class Severity(Enum):
+    """Accident severity levels."""
+    MINOR = "minor"
+    MODERATE = "moderate"
+    SEVERE = "severe"
+
+
+class RoadType(Enum):
+    """Types of roads."""
+    ROUNDABOUT = "roundabout"
+    INTERSECTION = "intersection"
+    HIGHWAY = "highway"
+    URBAN_ROAD = "urban_road"
+
+
+# ============================================================
+# DATA CLASSES
+# ============================================================
+
+@dataclass
+class Location:
+    """Geographic location data."""
+    name: str
+    name_arabic: str = ""
+    latitude: float = 0.0
+    longitude: float = 0.0
+    radius_meters: int = 150
+    city: str = ""
+    country: str = ""
+    road_type: RoadType = RoadType.ROUNDABOUT
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "name_arabic": self.name_arabic,
+            "latitude": self.latitude,
+            "longitude": self.longitude,
+            "radius_meters": self.radius_meters,
+            "city": self.city,
+            "country": self.country,
+            "road_type": self.road_type.value
+        }
+
+
+@dataclass
+class Conditions:
+    """Environmental conditions at time of accident."""
+    weather: WeatherCondition = WeatherCondition.CLEAR
+    road_condition: RoadCondition = RoadCondition.DRY
+    visibility: float = 1.0  # 0.0 to 1.0
+    lighting: str = "daylight"  # daylight, dusk, night, artificial
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "weather": self.weather.value,
+            "road_condition": self.road_condition.value,
+            "visibility": self.visibility,
+            "lighting": self.lighting
+        }
+
+
+@dataclass
+class VehicleData:
+    """Data for a single vehicle."""
+    vehicle_type: VehicleType = VehicleType.SEDAN
+    speed_kmh: float = 50.0
+    direction: Direction = Direction.NORTH
+    action: VehicleAction = VehicleAction.GOING_STRAIGHT
+    braking: bool = False
+    signaling: bool = False
+    lights_on: bool = True
+    horn_used: bool = False
+    path: List[Tuple[float, float]] = field(default_factory=list)
+    description: str = ""
+    
+    @property
+    def direction_angle(self) -> float:
+        """Convert direction to angle in degrees."""
+        angles = {
+            Direction.NORTH: 0,
+            Direction.NORTHEAST: 45,
+            Direction.EAST: 90,
+            Direction.SOUTHEAST: 135,
+            Direction.SOUTH: 180,
+            Direction.SOUTHWEST: 225,
+            Direction.WEST: 270,
+            Direction.NORTHWEST: 315
+        }
+        return angles.get(self.direction, 0)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "type": self.vehicle_type.value,
+            "speed_kmh": self.speed_kmh,
+            "direction": self.direction.value,
+            "direction_angle": self.direction_angle,
+            "action": self.action.value,
+            "braking": self.braking,
+            "signaling": self.signaling,
+            "lights_on": self.lights_on,
+            "horn_used": self.horn_used,
+            "path": self.path,
+            "description": self.description
+        }
+
+
+@dataclass
+class AccidentDetails:
+    """Details about the accident."""
+    accident_type: AccidentType = AccidentType.SIDE_IMPACT
+    severity: Severity = Severity.MODERATE
+    collision_angle: float = 90.0
+    collision_point: Tuple[float, float] = (0.0, 0.0)
+    contributing_factors: List[str] = field(default_factory=list)
+    fault_vehicle: int = 0  # 0 = undetermined, 1 or 2
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "type": self.accident_type.value,
+            "severity": self.severity.value,
+            "collision_angle": self.collision_angle,
+            "collision_point": list(self.collision_point),
+            "contributing_factors": self.contributing_factors,
+            "fault_vehicle": self.fault_vehicle
+        }
+
+
+@dataclass
+class ScenarioMetrics:
+    """Metrics for an accident scenario."""
+    collision_probability: float = 0.5
+    path_overlap: float = 0.5
+    speed_differential: float = 0.0
+    time_to_collision: float = 0.0
+    impact_force_estimate: float = 0.0
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "collision_probability": self.collision_probability,
+            "path_overlap": self.path_overlap,
+            "speed_differential": self.speed_differential,
+            "time_to_collision": self.time_to_collision,
+            "impact_force_estimate": self.impact_force_estimate
+        }
+
+
+@dataclass
+class Scenario:
+    """A single accident scenario."""
+    scenario_id: int = 0
+    accident_type: AccidentType = AccidentType.SIDE_IMPACT
+    probability: float = 0.5
+    description: str = ""
+    contributing_factors: List[str] = field(default_factory=list)
+    metrics: ScenarioMetrics = field(default_factory=ScenarioMetrics)
+    vehicle_1_path: List[Tuple[float, float]] = field(default_factory=list)
+    vehicle_2_path: List[Tuple[float, float]] = field(default_factory=list)
+    collision_point: Tuple[float, float] = (0.0, 0.0)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.scenario_id,
+            "accident_type": self.accident_type.value,
+            "probability": self.probability,
+            "description": self.description,
+            "contributing_factors": self.contributing_factors,
+            "metrics": self.metrics.to_dict(),
+            "vehicle_1_path": self.vehicle_1_path,
+            "vehicle_2_path": self.vehicle_2_path,
+            "collision_point": list(self.collision_point)
+        }
+
+
+@dataclass
+class FaultAssessment:
+    """Preliminary fault assessment."""
+    vehicle_1_contribution: float = 50.0  # Percentage
+    vehicle_2_contribution: float = 50.0
+    likely_at_fault: int = 0  # 0 = undetermined, 1 or 2
+    primary_factor: str = ""
+    confidence: float = 0.5
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "vehicle_1_contribution": self.vehicle_1_contribution,
+            "vehicle_2_contribution": self.vehicle_2_contribution,
+            "likely_at_fault": self.likely_at_fault,
+            "primary_factor": self.primary_factor,
+            "confidence": self.confidence
+        }
+
+
+@dataclass
+class TimelineEvent:
+    """An event in the accident timeline."""
+    time_offset: float = 0.0  # Seconds relative to collision (negative = before)
+    event: str = ""
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "time": self.time_offset,
+            "event": self.event
+        }
+
+
+@dataclass 
+class AccidentRecord:
+    """Complete accident record."""
+    accident_id: str = ""
+    timestamp: datetime = field(default_factory=datetime.now)
+    location: Location = field(default_factory=Location)
+    conditions: Conditions = field(default_factory=Conditions)
+    vehicle_1: VehicleData = field(default_factory=VehicleData)
+    vehicle_2: VehicleData = field(default_factory=VehicleData)
+    accident_details: AccidentDetails = field(default_factory=AccidentDetails)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "accident_id": self.accident_id,
+            "timestamp": self.timestamp.isoformat(),
+            "location": self.location.to_dict(),
+            "conditions": self.conditions.to_dict(),
+            "vehicle_1": self.vehicle_1.to_dict(),
+            "vehicle_2": self.vehicle_2.to_dict(),
+            "accident_details": self.accident_details.to_dict()
+        }
+
+
+@dataclass
+class AnalysisResult:
+    """Results from AI analysis."""
+    scenarios: List[Scenario] = field(default_factory=list)
+    most_likely_scenario_id: int = 0
+    overall_collision_probability: float = 0.5
+    fault_assessment: FaultAssessment = field(default_factory=FaultAssessment)
+    timeline: List[TimelineEvent] = field(default_factory=list)
+    analysis_timestamp: datetime = field(default_factory=datetime.now)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "scenarios": [s.to_dict() for s in self.scenarios],
+            "most_likely_scenario": {
+                "id": self.most_likely_scenario_id,
+                "probability": self.scenarios[self.most_likely_scenario_id - 1].probability 
+                    if self.scenarios else 0
+            },
+            "overall_collision_probability": self.overall_collision_probability,
+            "preliminary_fault_assessment": self.fault_assessment.to_dict(),
+            "timeline": [e.to_dict() for e in self.timeline],
+            "analysis_timestamp": self.analysis_timestamp.isoformat()
+        }
+
+
+# ============================================================
+# FEATURE VECTOR SCHEMA (for MindSpore)
+# ============================================================
+
+FEATURE_SCHEMA = {
+    "input_features": [
+        # Vehicle 1 features (7)
+        "v1_type_encoded",       # 0-4 normalized
+        "v1_speed_normalized",   # 0-1 (speed/200)
+        "v1_direction_encoded",  # 0-1 (direction/8)
+        "v1_angle_normalized",   # 0-1 (angle/360)
+        "v1_action_encoded",     # 0-1 (action/10)
+        "v1_braking",            # 0 or 1
+        "v1_signaling",          # 0 or 1
+        
+        # Vehicle 2 features (7)
+        "v2_type_encoded",
+        "v2_speed_normalized",
+        "v2_direction_encoded",
+        "v2_angle_normalized",
+        "v2_action_encoded",
+        "v2_braking",
+        "v2_signaling",
+        
+        # Environmental features (3)
+        "weather_encoded",       # 0-1 (weather/5)
+        "road_condition_encoded",# 0-1 (condition/4)
+        "visibility",            # 0-1
+        
+        # Derived features (6)
+        "collision_angle_normalized",  # 0-1 (angle/180)
+        "speed_differential",          # 0-1 (diff/200)
+        "combined_speed_normalized",   # 0-1 (sum/400)
+        "same_direction",              # 0 or 1
+        "speed_product_normalized",    # 0-1
+        "angle_difference_normalized"  # -1 to 1
+    ],
+    "total_input_features": 23,
+    
+    "output_labels": [
+        "rear_end_collision",
+        "side_impact",
+        "head_on_collision",
+        "sideswipe",
+        "roundabout_entry_collision",
+        "lane_change_collision",
+        "intersection_collision"
+    ],
+    "total_output_classes": 7
+}
+
+
+# ============================================================
+# VALIDATION FUNCTIONS
+# ============================================================
+
+def validate_speed(speed: float, vehicle_type: VehicleType) -> bool:
+    """Validate speed is within acceptable range for vehicle type."""
+    max_speeds = {
+        VehicleType.SEDAN: 180,
+        VehicleType.SUV: 160,
+        VehicleType.TRUCK: 120,
+        VehicleType.MOTORCYCLE: 200,
+        VehicleType.BUS: 100
+    }
+    return 0 <= speed <= max_speeds.get(vehicle_type, 200)
+
+
+def validate_coordinates(lat: float, lng: float) -> bool:
+    """Validate geographic coordinates."""
+    return -90 <= lat <= 90 and -180 <= lng <= 180
+
+
+def validate_path(path: List[Tuple[float, float]]) -> bool:
+    """Validate vehicle path has at least 2 points."""
+    if len(path) < 2:
+        return False
+    return all(validate_coordinates(p[0], p[1]) for p in path)
+
+
+def validate_probability(prob: float) -> bool:
+    """Validate probability is between 0 and 1."""
+    return 0 <= prob <= 1

data/synthetic_dataset_generator.py

@@ -0,0 +1,967 @@
+"""
+Synthetic Accident Dataset Generator
+=====================================
+Generates realistic synthetic traffic accident data for training
+the MindSpore AI model.
+
+This dataset simulates various accident scenarios at roundabouts
+with different vehicle types, speeds, directions, and conditions.
+"""
+
+import numpy as np
+import pandas as pd
+import json
+import random
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, List, Tuple, Any
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from config import (
+    CASE_STUDY_LOCATION,
+    VEHICLE_TYPES,
+    ACCIDENT_TYPES,
+    CONTRIBUTING_FACTORS,
+    ROAD_TYPES,
+    DATA_DIR,
+    PROCESSED_DATA_DIR
+)
+
+
+# ============================================================
+# CONSTANTS FOR DATA GENERATION
+# ============================================================
+
+# Directions with angles (for roundabout entry/exit)
+DIRECTIONS = {
+    'north': 0,
+    'northeast': 45,
+    'east': 90,
+    'southeast': 135,
+    'south': 180,
+    'southwest': 225,
+    'west': 270,
+    'northwest': 315
+}
+
+# Actions vehicles can take
+VEHICLE_ACTIONS = [
+    'going_straight',
+    'turning_left',
+    'turning_right',
+    'entering_roundabout',
+    'exiting_roundabout',
+    'changing_lane_left',
+    'changing_lane_right',
+    'slowing_down',
+    'accelerating',
+    'stopped'
+]
+
+# Weather conditions with probability weights
+WEATHER_CONDITIONS = {
+    'clear': 0.55,
+    'cloudy': 0.20,
+    'rainy': 0.12,
+    'foggy': 0.07,
+    'sandstorm': 0.06
+}
+
+# Road conditions with probability weights
+ROAD_CONDITIONS = {
+    'dry': 0.65,
+    'wet': 0.18,
+    'sandy': 0.12,
+    'oily': 0.05
+}
+
+# Road types with probability weights (expanded)
+ROAD_TYPE_WEIGHTS = {
+    'roundabout': 0.30,
+    'crossroad': 0.25,
+    't_junction': 0.15,
+    'highway_merge': 0.10,
+    'parking': 0.05,
+    'highway': 0.08,
+    'urban_road': 0.05,
+    'other': 0.02
+}
+
+# Time of day distribution (hour: probability)
+TIME_DISTRIBUTION = {
+    'morning_rush': (7, 9, 0.25),      # 7-9 AM, 25% of accidents
+    'midday': (10, 15, 0.20),          # 10 AM - 3 PM, 20%
+    'evening_rush': (16, 19, 0.30),    # 4-7 PM, 30%
+    'night': (20, 23, 0.15),           # 8-11 PM, 15%
+    'late_night': (0, 6, 0.10)         # Midnight - 6 AM, 10%
+}
+
+# Lighting conditions
+LIGHTING_CONDITIONS = ['daylight', 'dusk', 'dawn', 'night_lit', 'night_dark']
+
+
+# ============================================================
+# DATA SCHEMA DEFINITION
+# ============================================================
+
+ACCIDENT_SCHEMA = {
+    "accident_id": "string",
+    "timestamp": "datetime",
+    "location": {
+        "name": "string",
+        "latitude": "float",
+        "longitude": "float",
+        "road_type": "string"
+    },
+    "conditions": {
+        "weather": "string",
+        "road_condition": "string",
+        "visibility": "float",  # 0-1 scale
+        "lighting": "string"    # daylight, dusk, night, artificial
+    },
+    "vehicle_1": {
+        "type": "string",
+        "speed_kmh": "float",
+        "direction": "string",
+        "direction_angle": "float",
+        "action": "string",
+        "braking": "boolean",
+        "signaling": "boolean",
+        "path": "list[tuple]"
+    },
+    "vehicle_2": {
+        "type": "string",
+        "speed_kmh": "float",
+        "direction": "string",
+        "direction_angle": "float",
+        "action": "string",
+        "braking": "boolean",
+        "signaling": "boolean",
+        "path": "list[tuple]"
+    },
+    "accident_details": {
+        "type": "string",
+        "severity": "string",      # minor, moderate, severe
+        "collision_angle": "float",
+        "collision_point": "tuple",
+        "contributing_factors": "list[string]",
+        "fault_vehicle": "int"    # 1 or 2
+    },
+    "outcomes": {
+        "scenario_probability": "float",
+        "damage_estimate": "string",
+        "injuries": "boolean"
+    }
+}
+
+
+# ============================================================
+# HELPER FUNCTIONS
+# ============================================================
+
+def generate_accident_id() -> str:
+    """Generate unique accident ID."""
+    timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+    random_suffix = ''.join(random.choices('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', k=4))
+    return f"ACC-{timestamp}-{random_suffix}"
+
+
+def generate_timestamp() -> datetime:
+    """Generate realistic accident timestamp based on distribution."""
+    # Select time period based on weights
+    period = random.choices(
+        list(TIME_DISTRIBUTION.keys()),
+        weights=[v[2] for v in TIME_DISTRIBUTION.values()]
+    )[0]
+    
+    start_hour, end_hour, _ = TIME_DISTRIBUTION[period]
+    
+    # Generate random date within last year
+    days_ago = random.randint(0, 365)
+    base_date = datetime.now() - timedelta(days=days_ago)
+    
+    # Generate random time within period
+    hour = random.randint(start_hour, end_hour)
+    minute = random.randint(0, 59)
+    
+    return base_date.replace(hour=hour, minute=minute, second=0, microsecond=0)
+
+
+def select_weather() -> Tuple[str, float]:
+    """Select weather condition and corresponding visibility."""
+    weather = random.choices(
+        list(WEATHER_CONDITIONS.keys()),
+        weights=list(WEATHER_CONDITIONS.values())
+    )[0]
+    
+    visibility_map = {
+        'clear': random.uniform(0.9, 1.0),
+        'cloudy': random.uniform(0.8, 0.95),
+        'rainy': random.uniform(0.5, 0.8),
+        'foggy': random.uniform(0.2, 0.5),
+        'sandstorm': random.uniform(0.1, 0.4)
+    }
+    
+    return weather, visibility_map[weather]
+
+
+def select_road_condition(weather: str) -> str:
+    """Select road condition based on weather."""
+    if weather == 'rainy':
+        return 'wet'
+    elif weather == 'sandstorm':
+        return random.choice(['sandy', 'dry'])
+    else:
+        return random.choices(
+            list(ROAD_CONDITIONS.keys()),
+            weights=list(ROAD_CONDITIONS.values())
+        )[0]
+
+
+def generate_vehicle_data(vehicle_num: int, accident_type: str, road_type: str = 'roundabout') -> Dict:
+    """Generate realistic vehicle data based on accident type and road type."""
+    
+    # Select vehicle type with realistic distribution
+    vehicle_type = random.choices(
+        list(VEHICLE_TYPES.keys()),
+        weights=[0.50, 0.30, 0.10, 0.05, 0.05]  # sedan most common
+    )[0]
+    
+    specs = VEHICLE_TYPES[vehicle_type]
+    
+    # Generate speed based on accident type and road type
+    speed_modifier = {
+        'roundabout': 0.6,
+        'crossroad': 0.7,
+        't_junction': 0.65,
+        'highway_merge': 0.9,
+        'parking': 0.2,
+        'highway': 1.0,
+        'urban_road': 0.5,
+        'other': 0.6
+    }.get(road_type, 0.6)
+    
+    if accident_type == 'rear_end_collision':
+        if vehicle_num == 1:
+            speed = random.uniform(20, 50) * speed_modifier
+        else:
+            speed = random.uniform(40, 80) * speed_modifier
+    elif accident_type == 'head_on_collision':
+        speed = random.uniform(50, 100) * speed_modifier
+    elif accident_type in ['roundabout_entry_collision', 'intersection_collision']:
+        speed = random.uniform(30, 60) * speed_modifier
+    else:
+        speed = random.uniform(30, specs['max_speed'] * 0.7) * speed_modifier
+    
+    # Ensure speed doesn't exceed vehicle max
+    speed = min(speed, specs['max_speed'])
+    
+    # Select direction
+    direction = random.choice(list(DIRECTIONS.keys()))
+    
+    # Select action based on accident type and road type
+    if road_type == 'roundabout':
+        if accident_type == 'roundabout_entry_collision':
+            action = random.choice(['entering_roundabout', 'going_straight'])
+        else:
+            action = random.choice(['entering_roundabout', 'exiting_roundabout', 'going_straight'])
+    elif road_type in ['crossroad', 't_junction']:
+        action = random.choice(['going_straight', 'turning_left', 'turning_right', 'stopped'])
+    elif road_type == 'highway_merge':
+        action = random.choice(['going_straight', 'changing_lane_left', 'changing_lane_right', 'accelerating'])
+    elif road_type == 'parking':
+        action = random.choice(['slowing_down', 'stopped', 'going_straight'])
+    elif road_type == 'highway':
+        action = random.choice(['going_straight', 'changing_lane_left', 'changing_lane_right'])
+    else:
+        if accident_type == 'lane_change_collision':
+            action = random.choice(['changing_lane_left', 'changing_lane_right'])
+        elif accident_type == 'rear_end_collision':
+            action = 'going_straight' if vehicle_num == 2 else random.choice(['slowing_down', 'stopped'])
+        else:
+            action = random.choice(VEHICLE_ACTIONS)
+    
+    # Braking and signaling
+    braking = random.random() < 0.4  # 40% chance of braking
+    signaling = random.random() < 0.3  # 30% chance of signaling
+    
+    # Generate simplified path (entry point, intermediate, collision area)
+    path = generate_vehicle_path(direction, accident_type)
+    
+    return {
+        'type': vehicle_type,
+        'speed_kmh': round(speed, 1),
+        'direction': direction,
+        'direction_angle': DIRECTIONS[direction],
+        'action': action,
+        'braking': braking,
+        'signaling': signaling,
+        'path': path
+    }
+
+
+def generate_vehicle_path(direction: str, accident_type: str) -> List[List[float]]:
+    """Generate a realistic vehicle path for the roundabout."""
+    
+    base_lat = CASE_STUDY_LOCATION['latitude']
+    base_lng = CASE_STUDY_LOCATION['longitude']
+    
+    # Offset based on direction (entry points)
+    direction_offsets = {
+        'north': (0.002, 0),
+        'south': (-0.002, 0),
+        'east': (0, 0.002),
+        'west': (0, -0.002),
+        'northeast': (0.0015, 0.0015),
+        'northwest': (0.0015, -0.0015),
+        'southeast': (-0.0015, 0.0015),
+        'southwest': (-0.0015, -0.0015)
+    }
+    
+    offset = direction_offsets.get(direction, (0.002, 0))
+    
+    # Generate path points
+    start_lat = base_lat + offset[0]
+    start_lng = base_lng + offset[1]
+    
+    # Path moves toward center (collision zone)
+    path = [
+        [start_lat, start_lng],
+        [start_lat - offset[0] * 0.5, start_lng - offset[1] * 0.5],
+        [base_lat + random.uniform(-0.0003, 0.0003), 
+         base_lng + random.uniform(-0.0003, 0.0003)]
+    ]
+    
+    return path
+
+
+def calculate_collision_angle(v1_direction: str, v2_direction: str) -> float:
+    """Calculate the angle of collision between two vehicles."""
+    angle1 = DIRECTIONS[v1_direction]
+    angle2 = DIRECTIONS[v2_direction]
+    
+    diff = abs(angle1 - angle2)
+    if diff > 180:
+        diff = 360 - diff
+    
+    return diff
+
+
+def determine_accident_type(v1_direction: str, v2_direction: str, 
+                           v1_action: str, v2_action: str,
+                           road_type: str = 'roundabout') -> str:
+    """Determine accident type based on vehicle directions, actions, and road type."""
+    
+    collision_angle = calculate_collision_angle(v1_direction, v2_direction)
+    
+    # Head-on: ~180 degrees
+    if collision_angle > 150:
+        return 'head_on_collision'
+    
+    # Rear-end: ~0 degrees, same direction
+    if collision_angle < 30:
+        return 'rear_end_collision'
+    
+    # Side impact: ~90 degrees
+    if 60 < collision_angle < 120:
+        return 'side_impact'
+    
+    # Roundabout specific
+    if road_type == 'roundabout' and ('roundabout' in v1_action or 'roundabout' in v2_action):
+        return 'roundabout_entry_collision'
+    
+    # Lane change
+    if 'changing_lane' in v1_action or 'changing_lane' in v2_action:
+        return 'lane_change_collision'
+    
+    # Intersection/crossroad collision
+    if road_type in ['crossroad', 't_junction']:
+        return 'intersection_collision'
+    
+    # Default sideswipe for smaller angles
+    if 30 <= collision_angle <= 60:
+        return 'sideswipe'
+    
+    # Default to intersection collision
+    return 'intersection_collision'
+
+
+def determine_contributing_factors(
+    v1_data: Dict, 
+    v2_data: Dict, 
+    weather: str,
+    road_condition: str,
+    road_type: str = 'roundabout'
+) -> List[str]:
+    """Determine contributing factors based on accident data."""
+    
+    factors = []
+    
+    # Speed-related
+    speed_limits = {
+        'roundabout': 50, 'crossroad': 60, 't_junction': 50,
+        'highway_merge': 80, 'parking': 20, 'highway': 120, 'urban_road': 50, 'other': 60
+    }
+    speed_limit = speed_limits.get(road_type, 60)
+    
+    if v1_data['speed_kmh'] > speed_limit or v2_data['speed_kmh'] > speed_limit:
+        factors.append('speeding')
+    
+    # Following distance (for similar directions)
+    collision_angle = calculate_collision_angle(v1_data['direction'], v2_data['direction'])
+    if collision_angle < 30 and abs(v1_data['speed_kmh'] - v2_data['speed_kmh']) > 20:
+        factors.append('following_too_closely')
+    
+    # Failure to yield
+    if road_type == 'roundabout' and ('roundabout' in v1_data['action'] or 'roundabout' in v2_data['action']):
+        factors.append('failure_to_yield')
+    elif road_type in ['crossroad', 't_junction']:
+        if random.random() < 0.4:
+            factors.append('failure_to_yield')
+    
+    # Improper lane change
+    if 'changing_lane' in v1_data['action'] or 'changing_lane' in v2_data['action']:
+        factors.append('improper_lane_change')
+    
+    # Signaling
+    if not v1_data['signaling'] and ('turn' in v1_data['action'] or 'changing' in v1_data['action']):
+        factors.append('failure_to_signal')
+    
+    # Weather conditions
+    if weather in ['rainy', 'foggy', 'sandstorm']:
+        factors.append('weather_conditions')
+    
+    # Road conditions
+    if road_condition != 'dry':
+        factors.append('road_conditions')
+    
+    # Add some randomness
+    random_factors = ['distracted_driving', 'improper_turn', 'running_red_light', 'fatigue']
+    if random.random() < 0.3:
+        factors.append(random.choice(random_factors))
+    
+    return factors[:4]  # Limit to 4 factors
+
+
+def determine_fault(v1_data: Dict, v2_data: Dict, accident_type: str) -> int:
+    """Determine which vehicle is primarily at fault."""
+    
+    v1_score = 0
+    v2_score = 0
+    
+    # Speed factor
+    if v1_data['speed_kmh'] > v2_data['speed_kmh']:
+        v1_score += 1
+    else:
+        v2_score += 1
+    
+    # Signaling factor
+    if not v1_data['signaling']:
+        v1_score += 1
+    if not v2_data['signaling']:
+        v2_score += 1
+    
+    # Braking factor (not braking is worse)
+    if not v1_data['braking']:
+        v1_score += 1
+    if not v2_data['braking']:
+        v2_score += 1
+    
+    # Action-based fault
+    risky_actions = ['accelerating', 'changing_lane_left', 'changing_lane_right']
+    if v1_data['action'] in risky_actions:
+        v1_score += 1
+    if v2_data['action'] in risky_actions:
+        v2_score += 1
+    
+    # Rear-end: usually rear vehicle at fault
+    if accident_type == 'rear_end_collision':
+        v2_score += 2
+    
+    return 1 if v1_score > v2_score else 2
+
+
+def calculate_scenario_probability(
+    v1_data: Dict,
+    v2_data: Dict,
+    weather: str,
+    road_condition: str,
+    accident_type: str,
+    road_type: str = 'roundabout'
+) -> float:
+    """Calculate the probability of this accident scenario."""
+    
+    base_prob = 0.5
+    
+    # Road type risk factor
+    road_risk = {
+        'roundabout': 0.05, 'crossroad': 0.1, 't_junction': 0.08,
+        'highway_merge': 0.12, 'parking': -0.1, 'highway': 0.15,
+        'urban_road': 0.03, 'other': 0.05
+    }
+    base_prob += road_risk.get(road_type, 0.05)
+    
+    # Collision angle impact
+    collision_angle = calculate_collision_angle(v1_data['direction'], v2_data['direction'])
+    if 60 < collision_angle < 120:  # Side impact most likely at roundabout
+        base_prob += 0.15
+    elif collision_angle < 30:  # Rear-end
+        base_prob += 0.1
+    
+    # Speed impact
+    combined_speed = v1_data['speed_kmh'] + v2_data['speed_kmh']
+    if combined_speed > 100:
+        base_prob += 0.1
+    if combined_speed > 150:
+        base_prob += 0.1
+    
+    # Weather impact
+    weather_impact = {
+        'clear': 0, 'cloudy': 0.02, 'rainy': 0.08, 
+        'foggy': 0.1, 'sandstorm': 0.12
+    }
+    base_prob += weather_impact.get(weather, 0)
+    
+    # Road condition impact
+    road_impact = {'dry': 0, 'wet': 0.08, 'sandy': 0.1, 'oily': 0.15}
+    base_prob += road_impact.get(road_condition, 0)
+    
+    # Action risk
+    risky_actions = ['changing_lane_left', 'changing_lane_right', 'accelerating', 'entering_roundabout']
+    if v1_data['action'] in risky_actions:
+        base_prob += 0.05
+    if v2_data['action'] in risky_actions:
+        base_prob += 0.05
+    
+    # Not braking increases risk
+    if not v1_data['braking'] and not v2_data['braking']:
+        base_prob += 0.05
+    
+    # Add some randomness
+    base_prob += random.uniform(-0.1, 0.1)
+    
+    return max(0.1, min(0.95, base_prob))
+
+
+# ============================================================
+# MAIN DATASET GENERATION
+# ============================================================
+
+def generate_single_accident() -> Dict:
+    """Generate a single accident record."""
+    
+    # Generate basic info
+    accident_id = generate_accident_id()
+    timestamp = generate_timestamp()
+    weather, visibility = select_weather()
+    road_condition = select_road_condition(weather)
+    
+    # Select road type
+    road_type = random.choices(
+        list(ROAD_TYPE_WEIGHTS.keys()),
+        weights=list(ROAD_TYPE_WEIGHTS.values())
+    )[0]
+    
+    # Determine lighting based on time
+    hour = timestamp.hour
+    if 7 <= hour < 17:
+        lighting = 'daylight'
+    elif hour in [6, 17, 18]:
+        lighting = random.choice(['dusk', 'dawn'])
+    elif 19 <= hour <= 23 or 0 <= hour < 6:
+        lighting = random.choice(['night_lit', 'night_dark'])
+    else:
+        lighting = 'daylight'
+    
+    # Adjust visibility based on lighting
+    if lighting in ['night_dark']:
+        visibility = visibility * 0.6
+    elif lighting in ['night_lit']:
+        visibility = visibility * 0.8
+    elif lighting in ['dusk', 'dawn']:
+        visibility = visibility * 0.9
+    
+    # Pre-select accident type for more realistic data
+    accident_type = random.choice(ACCIDENT_TYPES)
+    
+    # Generate vehicle data
+    vehicle_1 = generate_vehicle_data(1, accident_type, road_type)
+    vehicle_2 = generate_vehicle_data(2, accident_type, road_type)
+    
+    # Recalculate accident type based on actual vehicle data
+    actual_accident_type = determine_accident_type(
+        vehicle_1['direction'], vehicle_2['direction'],
+        vehicle_1['action'], vehicle_2['action'],
+        road_type
+    )
+    
+    # Calculate collision details
+    collision_angle = calculate_collision_angle(
+        vehicle_1['direction'], vehicle_2['direction']
+    )
+    
+    # Collision point (near center of roundabout)
+    collision_point = [
+        CASE_STUDY_LOCATION['latitude'] + random.uniform(-0.0005, 0.0005),
+        CASE_STUDY_LOCATION['longitude'] + random.uniform(-0.0005, 0.0005)
+    ]
+    
+    # Determine contributing factors
+    factors = determine_contributing_factors(
+        vehicle_1, vehicle_2, weather, road_condition, road_type
+    )
+    
+    # Determine fault
+    fault_vehicle = determine_fault(vehicle_1, vehicle_2, actual_accident_type)
+    
+    # Determine severity
+    combined_speed = vehicle_1['speed_kmh'] + vehicle_2['speed_kmh']
+    if combined_speed > 120:
+        severity = 'severe'
+    elif combined_speed > 80:
+        severity = 'moderate'
+    else:
+        severity = 'minor'
+    
+    # Calculate probability
+    probability = calculate_scenario_probability(
+        vehicle_1, vehicle_2, weather, road_condition, actual_accident_type, road_type
+    )
+    
+    return {
+        'accident_id': accident_id,
+        'timestamp': timestamp.isoformat(),
+        'location': {
+            'name': CASE_STUDY_LOCATION['name'],
+            'latitude': CASE_STUDY_LOCATION['latitude'],
+            'longitude': CASE_STUDY_LOCATION['longitude'],
+            'road_type': road_type
+        },
+        'conditions': {
+            'weather': weather,
+            'road_condition': road_condition,
+            'visibility': round(visibility, 2),
+            'lighting': lighting
+        },
+        'vehicle_1': vehicle_1,
+        'vehicle_2': vehicle_2,
+        'accident_details': {
+            'type': actual_accident_type,
+            'severity': severity,
+            'collision_angle': collision_angle,
+            'collision_point': collision_point,
+            'contributing_factors': factors,
+            'fault_vehicle': fault_vehicle
+        },
+        'outcomes': {
+            'scenario_probability': round(probability, 3),
+            'damage_estimate': severity,
+            'injuries': severity in ['moderate', 'severe'] and random.random() > 0.4
+        }
+    }
+
+
+def generate_dataset(num_samples: int = 1000) -> pd.DataFrame:
+    """Generate a complete synthetic accident dataset."""
+    
+    print(f"Generating {num_samples} synthetic accident records...")
+    
+    accidents = []
+    for i in range(num_samples):
+        if (i + 1) % 1000 == 0:
+            print(f"  Generated {i + 1}/{num_samples} records...")
+        
+        accident = generate_single_accident()
+        
+        # Flatten for DataFrame
+        flat_record = {
+            'accident_id': accident['accident_id'],
+            'timestamp': accident['timestamp'],
+            'location_name': accident['location']['name'],
+            'latitude': accident['location']['latitude'],
+            'longitude': accident['location']['longitude'],
+            'road_type': accident['location']['road_type'],
+            'weather': accident['conditions']['weather'],
+            'road_condition': accident['conditions']['road_condition'],
+            'visibility': accident['conditions']['visibility'],
+            'lighting': accident['conditions']['lighting'],
+            
+            # Vehicle 1
+            'v1_type': accident['vehicle_1']['type'],
+            'v1_speed': accident['vehicle_1']['speed_kmh'],
+            'v1_direction': accident['vehicle_1']['direction'],
+            'v1_direction_angle': accident['vehicle_1']['direction_angle'],
+            'v1_action': accident['vehicle_1']['action'],
+            'v1_braking': accident['vehicle_1']['braking'],
+            'v1_signaling': accident['vehicle_1']['signaling'],
+            
+            # Vehicle 2
+            'v2_type': accident['vehicle_2']['type'],
+            'v2_speed': accident['vehicle_2']['speed_kmh'],
+            'v2_direction': accident['vehicle_2']['direction'],
+            'v2_direction_angle': accident['vehicle_2']['direction_angle'],
+            'v2_action': accident['vehicle_2']['action'],
+            'v2_braking': accident['vehicle_2']['braking'],
+            'v2_signaling': accident['vehicle_2']['signaling'],
+            
+            # Accident details
+            'accident_type': accident['accident_details']['type'],
+            'severity': accident['accident_details']['severity'],
+            'collision_angle': accident['accident_details']['collision_angle'],
+            'contributing_factors': ','.join(accident['accident_details']['contributing_factors']),
+            'fault_vehicle': accident['accident_details']['fault_vehicle'],
+            
+            # Outcomes
+            'scenario_probability': accident['outcomes']['scenario_probability'],
+            'injuries': accident['outcomes']['injuries']
+        }
+        
+        accidents.append(flat_record)
+    
+    df = pd.DataFrame(accidents)
+    print(f"Dataset generated with {len(df)} records.")
+    
+    return df
+
+
+def generate_training_features(df: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Convert dataset to feature vectors for MindSpore training.
+    
+    Features (32 total):
+    - Vehicle 1: type, speed, direction, angle, action, braking, signaling (7)
+    - Vehicle 2: type, speed, direction, angle, action, braking, signaling (7)
+    - Environment: weather, road_condition, visibility, lighting, road_type (5)
+    - Derived: collision_angle, speed_diff, combined_speed, same_direction,
+               speed_product, angle_diff, time_of_day, risk_score, 
+               v1_action_risk, v2_action_risk, relative_speed, approach_rate (12)
+    - Total: 31 input features
+    
+    Returns:
+        X: Feature matrix (N x 31)
+        y: Labels - accident type encoded (N,)
+    """
+    
+    # Encode categorical variables
+    direction_encoding = {d: i for i, d in enumerate(DIRECTIONS.keys())}
+    action_encoding = {a: i for i, a in enumerate(VEHICLE_ACTIONS)}
+    vehicle_encoding = {v: i for i, v in enumerate(VEHICLE_TYPES.keys())}
+    weather_encoding = {'clear': 0, 'cloudy': 1, 'rainy': 2, 'foggy': 3, 'sandstorm': 4}
+    road_encoding = {'dry': 0, 'wet': 1, 'sandy': 2, 'oily': 3}
+    road_type_encoding = {
+        'roundabout': 0, 'crossroad': 1, 't_junction': 2, 'highway_merge': 3,
+        'parking': 4, 'highway': 5, 'urban_road': 6, 'other': 7
+    }
+    lighting_encoding = {'daylight': 0, 'dusk': 1, 'dawn': 2, 'night_lit': 3, 'night_dark': 4}
+    accident_encoding = {a: i for i, a in enumerate(ACCIDENT_TYPES)}
+    
+    # Action risk scores
+    action_risk = {
+        'going_straight': 0.3, 'turning_left': 0.5, 'turning_right': 0.4,
+        'entering_roundabout': 0.6, 'exiting_roundabout': 0.5,
+        'changing_lane_left': 0.7, 'changing_lane_right': 0.7,
+        'slowing_down': 0.4, 'accelerating': 0.6, 'stopped': 0.2
+    }
+    
+    features = []
+    labels = []
+    
+    for _, row in df.iterrows():
+        # Extract time of day (hour) from timestamp if available
+        try:
+            hour = pd.to_datetime(row['timestamp']).hour
+        except:
+            hour = 12  # Default to noon
+        
+        # Calculate derived features
+        v1_speed = row['v1_speed']
+        v2_speed = row['v2_speed']
+        v1_angle = row['v1_direction_angle']
+        v2_angle = row['v2_direction_angle']
+        collision_angle = row['collision_angle']
+        
+        speed_diff = abs(v1_speed - v2_speed)
+        combined_speed = v1_speed + v2_speed
+        same_direction = 1 if row['v1_direction'] == row['v2_direction'] else 0
+        speed_product = v1_speed * v2_speed
+        angle_diff = (v1_angle - v2_angle) % 360
+        if angle_diff > 180:
+            angle_diff = 360 - angle_diff
+        
+        # Risk score based on conditions
+        weather_risk = {'clear': 0.1, 'cloudy': 0.2, 'rainy': 0.5, 'foggy': 0.7, 'sandstorm': 0.8}
+        road_risk = {'dry': 0.1, 'wet': 0.5, 'sandy': 0.6, 'oily': 0.8}
+        base_risk = weather_risk.get(row['weather'], 0.3) + road_risk.get(row['road_condition'], 0.3)
+        
+        # Relative speed (closing speed)
+        if angle_diff > 90:  # Approaching
+            relative_speed = v1_speed + v2_speed
+        else:  # Same direction
+            relative_speed = abs(v1_speed - v2_speed)
+        
+        # Approach rate (how quickly vehicles are approaching collision)
+        approach_rate = relative_speed * (1 - row['visibility']) * (1 + base_risk)
+        
+        feature_vector = [
+            # Vehicle 1 features (7)
+            vehicle_encoding.get(row['v1_type'], 0) / 5,
+            v1_speed / 200,  # Normalize speed
+            direction_encoding.get(row['v1_direction'], 0) / 8,
+            v1_angle / 360,
+            action_encoding.get(row['v1_action'], 0) / 10,
+            1 if row['v1_braking'] else 0,
+            1 if row['v1_signaling'] else 0,
+            
+            # Vehicle 2 features (7)
+            vehicle_encoding.get(row['v2_type'], 0) / 5,
+            v2_speed / 200,
+            direction_encoding.get(row['v2_direction'], 0) / 8,
+            v2_angle / 360,
+            action_encoding.get(row['v2_action'], 0) / 10,
+            1 if row['v2_braking'] else 0,
+            1 if row['v2_signaling'] else 0,
+            
+            # Environmental features (5)
+            weather_encoding.get(row['weather'], 0) / 5,
+            road_encoding.get(row['road_condition'], 0) / 4,
+            row['visibility'],
+            lighting_encoding.get(row.get('lighting', 'daylight'), 0) / 5,
+            road_type_encoding.get(row.get('road_type', 'roundabout'), 0) / 8,
+            
+            # Derived features (12)
+            collision_angle / 180,
+            speed_diff / 200,
+            combined_speed / 400,
+            same_direction,
+            speed_product / 40000,
+            angle_diff / 180,
+            hour / 24,  # Time of day
+            base_risk,  # Risk score
+            action_risk.get(row['v1_action'], 0.5),  # V1 action risk
+            action_risk.get(row['v2_action'], 0.5),  # V2 action risk
+            relative_speed / 400,  # Relative/closing speed
+            min(approach_rate / 200, 1.0),  # Approach rate (capped)
+        ]
+        
+        features.append(feature_vector)
+        labels.append(accident_encoding.get(row['accident_type'], 0))
+    
+    X = np.array(features, dtype=np.float32)
+    y = np.array(labels, dtype=np.int32)
+    
+    return X, y
+
+
+def generate_training_features_extended(df: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Extended feature generation that also outputs probability targets.
+    
+    Returns:
+        X: Feature matrix
+        y_class: Classification labels (accident type)
+        y_prob: Probability targets (for regression)
+    """
+    X, y_class = generate_training_features(df)
+    y_prob = df['scenario_probability'].values.astype(np.float32)
+    
+    return X, y_class, y_prob
+
+
+def save_dataset(df: pd.DataFrame, filename: str = "synthetic_accidents"):
+    """Save the dataset in multiple formats."""
+    
+    # Create directories if needed
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    PROCESSED_DATA_DIR.mkdir(parents=True, exist_ok=True)
+    
+    # Save as CSV
+    csv_path = PROCESSED_DATA_DIR / f"{filename}.csv"
+    df.to_csv(csv_path, index=False)
+    print(f"Saved CSV: {csv_path}")
+    
+    # Save as JSON (full records)
+    json_path = PROCESSED_DATA_DIR / f"{filename}.json"
+    df.to_json(json_path, orient='records', indent=2)
+    print(f"Saved JSON: {json_path}")
+    
+    # Generate and save training features
+    X, y = generate_training_features(df)
+    
+    np_path = PROCESSED_DATA_DIR / f"{filename}_features.npz"
+    np.savez(np_path, X=X, y=y)
+    print(f"Saved NumPy features: {np_path}")
+    
+    # Save schema
+    schema_path = DATA_DIR / "accident_schema.json"
+    with open(schema_path, 'w') as f:
+        json.dump(ACCIDENT_SCHEMA, f, indent=2)
+    print(f"Saved schema: {schema_path}")
+    
+    return csv_path, json_path, np_path
+
+
+def print_dataset_statistics(df: pd.DataFrame):
+    """Print statistics about the generated dataset."""
+    
+    print("\n" + "="*60)
+    print("DATASET STATISTICS")
+    print("="*60)
+    
+    print(f"\nTotal records: {len(df)}")
+    
+    print(f"\n--- Accident Types ---")
+    print(df['accident_type'].value_counts())
+    
+    print(f"\n--- Weather Conditions ---")
+    print(df['weather'].value_counts())
+    
+    print(f"\n--- Road Conditions ---")
+    print(df['road_condition'].value_counts())
+    
+    print(f"\n--- Severity Distribution ---")
+    print(df['severity'].value_counts())
+    
+    print(f"\n--- Vehicle Types (V1) ---")
+    print(df['v1_type'].value_counts())
+    
+    print(f"\n--- Speed Statistics ---")
+    print(f"V1 Speed: Mean={df['v1_speed'].mean():.1f}, Std={df['v1_speed'].std():.1f}")
+    print(f"V2 Speed: Mean={df['v2_speed'].mean():.1f}, Std={df['v2_speed'].std():.1f}")
+    
+    print(f"\n--- Fault Distribution ---")
+    print(df['fault_vehicle'].value_counts())
+    
+    print(f"\n--- Injuries ---")
+    print(df['injuries'].value_counts())
+    
+    print("\n" + "="*60)
+
+
+# ============================================================
+# MAIN EXECUTION
+# ============================================================
+
+if __name__ == "__main__":
+    print("="*60)
+    print("SYNTHETIC ACCIDENT DATASET GENERATOR")
+    print("Huawei AI Innovation Challenge 2026")
+    print("="*60)
+    
+    # Generate dataset
+    df = generate_dataset(num_samples=1000)
+    
+    # Print statistics
+    print_dataset_statistics(df)
+    
+    # Save dataset
+    csv_path, json_path, np_path = save_dataset(df)
+    
+    print("\n" + "="*60)
+    print("DATASET GENERATION COMPLETE!")
+    print("="*60)
+    print(f"\nFiles saved:")
+    print(f"  - {csv_path}")
+    print(f"  - {json_path}")
+    print(f"  - {np_path}")