Upload 13 files

.env

@@ -0,0 +1,20 @@
+# Server Configuration
+GRADIO_SERVER_NAME=0.0.0.0
+GRADIO_SERVER_PORT=7860
+GRADIO_SHARE=true
+
+# Model Configuration
+ANPR_CONFIDENCE=0.45
+HELMET_CONFIDENCE=0.5
+
+# Logging Configuration
+LOG_LEVEL=INFO
+LOG_FILE=app.log
+
+# Performance Configuration
+MAX_THREADS=40
+QUEUE_ENABLED=true
+
+# Security Configuration
+API_OPEN=false
+SSL_VERIFY=true 

.gitignore

@@ -0,0 +1,54 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Model files
+*.pt
+*.pth
+*.onnx
+*.h5
+
+# Logs
+*.log
+logs/
+
+# Local development
+.env
+.env.local
+.env.*.local
+
+# Docker
+.docker/
+
+# System Files
+.DS_Store
+Thumbs.db 

.windsurf-rules

@@ -0,0 +1,109 @@
+
+# Combined ANPR and Helmet Detection System
+
+## Overview
+
+This system integrates Automatic Number Plate Recognition (ANPR) for Indian vehicles with helmet detection for two-wheeler riders. It aims to enhance traffic safety monitoring by identifying vehicle registration numbers and checking for helmet usage in a single interface.
+
+## Rules and Guidelines
+
+1. **Input**: The system accepts images or video frames containing vehicles, preferably motorcycles or scooters.
+
+2. **ANPR Functionality**:
+   - Detects and reads license plates of Indian vehicles.
+   - Supports various Indian license plate formats.
+   - Provides the recognized license plate number as text.
+
+3. **Helmet Detection**:
+   - Identifies if the rider (and pillion rider, if present) is wearing a helmet.
+   - Returns a boolean value: True if helmet(s) detected, False otherwise.
+
+4. **Combined Output**:
+   - License Plate Number
+   - Helmet Status (Yes/No)
+   - Confidence scores for both detections
+
+5. **Error Handling**:
+   - If no license plate is detected, return "No plate detected"
+   - If no person is detected for helmet check, return "No rider detected"
+
+## Workflow
+
+1. User uploads an image or video frame to the system.
+2. System processes the image through both ANPR and helmet detection models simultaneously.
+3. ANPR model identifies and reads the license plate.
+4. Helmet detection model checks for the presence of helmets on riders.
+5. Results from both models are combined into a single output.
+6. The system displays the results to the user.
+
+## Usage Examples
+
+### Example 1: Compliant Rider
+
+**Input**: Image of a motorcycle with a clearly visible license plate and rider wearing a helmet.
+
+**Output**:
+```
+
+License Plate: DL 5S AB 1234
+Helmet Detected: Yes
+ANPR Confidence: 98%
+Helmet Detection Confidence: 95%
+
+```
+
+### Example 2: Non-compliant Rider
+
+**Input**: Image of a scooter with visible license plate but rider not wearing a helmet.
+
+**Output**:
+```
+
+License Plate: MH 01 AB 5678
+Helmet Detected: No
+ANPR Confidence: 97%
+Helmet Detection Confidence: 99%
+
+```
+
+### Example 3: Multiple Riders
+
+**Input**: Image of a motorcycle with two riders, both wearing helmets.
+
+**Output**:
+```
+
+License Plate: KA 01 EF 9876
+Helmet Detected: Yes
+ANPR Confidence: 96%
+Helmet Detection Confidence: 98%
+Note: Multiple helmets detected
+
+```
+
+### Example 4: Unclear Image
+
+**Input**: Blurry image of a vehicle with partially visible license plate.
+
+**Output**:
+```
+
+License Plate: ?N 02 X? 43??
+Helmet Detected: Uncertain
+ANPR Confidence: 60%
+Helmet Detection Confidence: 40%
+Note: Low quality image, results may be inaccurate
+
+```
+
+## Best Practices
+
+1. Use high-resolution images for better accuracy.
+2. Ensure proper lighting conditions in the input images.
+3. For video processing, select frames with clear views of both license plate and rider(s).
+4. Regularly update the model with new training data to improve accuracy.
+5. Use the confidence scores to filter out low-confidence detections if needed.
+
+By following these guidelines and understanding the workflow, users can effectively utilize this combined ANPR and helmet detection system for traffic safety monitoring and enforcement.
+```
+

Dockerfile

@@ -0,0 +1,33 @@
+# Use an official Python runtime as a parent image
+FROM python:3.8-slim
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the project files
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p ANPR_IND Helmet-Detect-model
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Command to run the application
+CMD ["python", "app.py"] 

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Traffic Violation Detection System
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

README.md

@@ -1,10 +1,90 @@
----
-license: mit
-title: ' Helmet_Detection_OCR_ANPR'
-sdk: gradio
-emoji: 🌍
-colorFrom: yellow
-colorTo: yellow
-thumbnail: >-
-  https://cdn-uploads.huggingface.co/production/uploads/651bfdb7164539754da51704/EMsp-wyEPULTGAS3KRbDT.png
----
+# Combined ANPR and Helmet Detection System
+
+A comprehensive traffic violation detection system that combines Automatic Number Plate Recognition (ANPR) and Helmet Detection using YOLOv8.
+
+## Features
+
+- Real-time license plate detection and recognition
+- Helmet detection for two-wheeler riders
+- Modern Gradio interface with real-time processing
+- Adjustable confidence threshold for detection
+- Combined visual annotations from both models
+- Queue support for multiple users
+- Comprehensive error handling
+
+## Prerequisites
+
+- Python 3.8 or higher
+- CUDA-capable GPU (recommended for better performance)
+- 8GB RAM minimum
+
+## Installation
+
+1. Clone the repository:
+```bash
+git clone <repository-url>
+cd <repository-name>
+```
+
+2. Create and activate a virtual environment:
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+3. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+1. Start the application:
+```bash
+python app.py
+```
+
+2. Open your web browser and navigate to:
+```
+http://localhost:7860
+```
+
+3. Upload an image or use the example images to test the system.
+
+## Model Files
+
+The following model files are required:
+- `ANPR_IND/licence_plat.pt`: License plate detection model
+- `ANPR_IND/licence_character.pt`: Character recognition model
+- `Helmet-Detect-model/best.pt`: Helmet detection model
+
+## API Endpoints
+
+The application exposes the following endpoints:
+- `/api/predict`: POST endpoint for image processing
+- `/api/health`: GET endpoint for health check
+
+## Deployment
+
+### Local Deployment
+```bash
+python app.py
+```
+
+### Docker Deployment
+```bash
+docker build -t traffic-detection .
+docker run -p 7860:7860 traffic-detection
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a new Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details. 

app.log

@@ -0,0 +1,34 @@
+2025-03-13 02:10:10,344 - __main__ - INFO - Initializing models...
+2025-03-13 02:10:11,230 - __main__ - INFO - Models initialized successfully
+2025-03-13 02:10:11,230 - __main__ - INFO - Starting application...
+2025-03-13 02:10:11,597 - __main__ - ERROR - Failed to start application: Blocks.launch() got an unexpected keyword argument 'enable_queue'
+2025-03-13 02:10:12,209 - httpx - INFO - HTTP Request: GET https://checkip.amazonaws.com/ "HTTP/1.1 200 "
+2025-03-13 02:10:13,083 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-03-13 02:14:18,845 - __main__ - INFO - Initializing models...
+2025-03-13 02:14:19,268 - __main__ - INFO - Models initialized successfully
+2025-03-13 02:14:19,268 - __main__ - INFO - Starting application...
+2025-03-13 02:14:19,451 - __main__ - ERROR - Failed to start application: Blocks.launch() got an unexpected keyword argument 'api_open'
+2025-03-13 02:14:19,924 - httpx - INFO - HTTP Request: GET https://checkip.amazonaws.com/ "HTTP/1.1 200 "
+2025-03-13 02:14:20,859 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-03-13 02:17:00,449 - __main__ - INFO - Initializing models...
+2025-03-13 02:17:00,860 - __main__ - INFO - Models initialized successfully
+2025-03-13 02:17:00,861 - __main__ - INFO - Starting application...
+2025-03-13 02:17:01,542 - httpx - INFO - HTTP Request: GET https://checkip.amazonaws.com/ "HTTP/1.1 200 "
+2025-03-13 02:17:02,408 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-03-13 02:17:03,540 - httpx - INFO - HTTP Request: GET http://localhost:7860/startup-events "HTTP/1.1 200 OK"
+2025-03-13 02:17:05,598 - httpx - INFO - HTTP Request: HEAD http://localhost:7860/ "HTTP/1.1 200 OK"
+2025-03-13 02:17:06,829 - httpx - INFO - HTTP Request: GET https://api.gradio.app/v2/tunnel-request "HTTP/1.1 200 OK"
+2025-03-13 02:17:07,308 - httpx - INFO - HTTP Request: GET https://cdn-media.huggingface.co/frpc-gradio-0.2/frpc_windows_amd64.exe "HTTP/1.1 200 OK"
+2025-03-13 02:19:48,440 - __main__ - INFO - Initializing models...
+2025-03-13 02:19:48,979 - __main__ - INFO - Models initialized successfully
+2025-03-13 02:19:48,979 - __main__ - INFO - Starting application...
+2025-03-13 02:19:49,714 - httpx - INFO - HTTP Request: GET https://checkip.amazonaws.com/ "HTTP/1.1 200 "
+2025-03-13 02:19:49,722 - httpx - INFO - HTTP Request: GET http://127.0.0.1:7860/startup-events "HTTP/1.1 200 OK"
+2025-03-13 02:19:49,746 - httpx - INFO - HTTP Request: HEAD http://127.0.0.1:7860/ "HTTP/1.1 200 OK"
+2025-03-13 02:19:50,633 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-03-13 02:20:29,658 - __main__ - INFO - Processing image with confidence threshold: 0.707
+2025-03-13 02:20:29,671 - __main__ - INFO - Running ANPR detection
+2025-03-13 02:20:33,923 - __main__ - INFO - ANPR result: DR717S, 22AAN
+2025-03-13 02:20:33,925 - __main__ - INFO - Running helmet detection
+2025-03-13 02:20:34,658 - __main__ - INFO - Helmet detection result: No Helmet Detected
+2025-03-13 02:20:34,663 - __main__ - INFO - Processing completed in 5.01 seconds

app.py

@@ -0,0 +1,194 @@
+import os
+import sys
+import cv2
+import gradio as gr
+import numpy as np
+import logging
+from datetime import datetime
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('app.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Add the project root to Python path
+project_root = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(project_root)
+
+from ANPR_IND.scripts.charExtraction import CharExtraction
+from ANPR_IND.scripts.bboxAnnotator import BBOXAnnotator
+from ultralytics import YOLO
+
+# Initialize ANPR models and classes
+wPathPlat = os.path.join(project_root, "ANPR_IND", "licence_plat.pt")
+wPathChar = os.path.join(project_root, "ANPR_IND", "licence_character.pt")
+classList = np.array(['A','B','C','D','E','F','G','H','I','J','K','L','M',
+                    'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
+                    '0','1','2','3','4','5','6','7','8','9'])
+sizePlat = (416,200)
+
+# Initialize Helmet Detection model
+helmet_model_path = os.path.join(project_root, "Helmet-Detect-model", "best.pt")
+
+# Verify model files exist
+required_files = [wPathPlat, wPathChar, helmet_model_path]
+for file_path in required_files:
+    if not os.path.exists(file_path):
+        logger.error(f"Required model file not found: {file_path}")
+        raise FileNotFoundError(f"Required model file not found: {file_path}")
+
+# Initialize models
+try:
+    logger.info("Initializing models...")
+    helmet_model = YOLO(helmet_model_path)
+    extractor = CharExtraction(wPlatePath=wPathPlat, wCharacterPath=wPathChar, 
+                             classList=classList, sizePlate=sizePlat, conf=0.5)
+    annotator = BBOXAnnotator()
+    logger.info("Models initialized successfully")
+except Exception as e:
+    logger.error(f"Error initializing models: {str(e)}")
+    raise
+
+def process_image(image, conf=0.45):
+    start_time = datetime.now()
+    logger.info(f"Processing image with confidence threshold: {conf}")
+    
+    if image is None:
+        logger.warning("No image provided")
+        return None, "No image provided", "No image provided"
+    
+    try:
+        # Convert PIL Image to cv2 format if needed
+        if isinstance(image, str):
+            if not os.path.exists(image):
+                raise FileNotFoundError(f"Image file not found: {image}")
+            image = cv2.imread(image)
+            if image is None:
+                raise ValueError(f"Failed to read image: {image}")
+        else:
+            image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+        
+        # ANPR Detection
+        logger.info("Running ANPR detection")
+        bbox, plateNum, confidence = extractor.predict(image=image, conf=conf)
+        anpr_image, plateNum = annotator.draw_bbox(image.copy(), bbox, plateNum)
+        plate_text = ", ".join(plateNum) if plateNum else "No plate detected"
+        logger.info(f"ANPR result: {plate_text}")
+        
+        # Helmet Detection
+        logger.info("Running helmet detection")
+        results = helmet_model(image)
+        helmet_detected = len(results[0].boxes) > 0
+        helmet_status = "Helmet Detected" if helmet_detected else "No Helmet Detected"
+        logger.info(f"Helmet detection result: {helmet_status}")
+        
+        # Get annotated image from helmet detection
+        helmet_image = results[0].plot()
+        
+        # Combine annotations
+        try:
+            combined_image = cv2.addWeighted(anpr_image, 0.5, helmet_image, 0.5, 0)
+        except Exception as e:
+            logger.warning(f"Failed to combine annotations: {str(e)}")
+            combined_image = helmet_image
+        
+        # Convert BGR to RGB for display
+        if isinstance(combined_image, np.ndarray):
+            combined_image = cv2.cvtColor(combined_image, cv2.COLOR_BGR2RGB)
+        
+        processing_time = (datetime.now() - start_time).total_seconds()
+        logger.info(f"Processing completed in {processing_time:.2f} seconds")
+        
+        return combined_image, plate_text, helmet_status
+        
+    except Exception as e:
+        logger.error(f"Error processing image: {str(e)}")
+        return image, f"Error: {str(e)}", "Error processing image"
+
+# Create example images array
+example_images = [
+    os.path.join(project_root, "ANPR_IND", "sample_image2.jpg"),
+    os.path.join(project_root, "ANPR_IND", "sample_image3.jpg"),
+    os.path.join(project_root, "ANPR_IND", "sample_image5.jpg"),
+    os.path.join(project_root, "ANPR_IND", "sample_image6.jpg")
+]
+
+# Verify example images exist
+for img_path in example_images:
+    if not os.path.exists(img_path):
+        logger.warning(f"Example image not found: {img_path}")
+        example_images.remove(img_path)
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(title="Traffic Violation Detection System", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# Combined ANPR and Helmet Detection System")
+        gr.Markdown("Upload an image to detect license plates and check for helmet usage.")
+        
+        with gr.Row():
+            with gr.Column():
+                input_image = gr.Image(label="Input Image", type="pil")
+                conf_slider = gr.Slider(minimum=0.1, maximum=1.0, value=0.45, 
+                                     label="Confidence Threshold")
+                detect_button = gr.Button("Detect", variant="primary")
+            
+            with gr.Column():
+                output_image = gr.Image(label="Annotated Image")
+                plate_output = gr.Textbox(label="License Plate")
+                helmet_output = gr.Textbox(label="Helmet Status")
+        
+        # Set up example images
+        if example_images:
+            gr.Examples(
+                examples=[[img, 0.45] for img in example_images],
+                inputs=[input_image, conf_slider],
+                outputs=[output_image, plate_output, helmet_output],
+                fn=process_image,
+                cache_examples=True
+            )
+        
+        # Set up the click event
+        detect_button.click(
+            fn=process_image,
+            inputs=[input_image, conf_slider],
+            outputs=[output_image, plate_output, helmet_output]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    try:
+        logger.info("Starting application...")
+        demo = create_interface()
+        demo.queue()  # Enable queue separately
+        
+        # Configure FastAPI app with custom settings
+        demo.launch(
+            share=False,  # Disable share link by default
+            server_name="127.0.0.1",  # Use localhost instead of 0.0.0.0
+            server_port=7860,
+            favicon_path=None,
+            auth=None,
+            ssl_keyfile=None,
+            ssl_certfile=None,
+            ssl_verify=True,
+            quiet=False,
+            show_api=True,
+            root_path="",
+            _frontend=True,
+            prevent_thread_lock=False,
+            allowed_paths=None,
+            blocked_paths=None,
+            max_threads=40,
+            debug=True  # Enable debug mode for better error reporting
+        )
+    except Exception as e:
+        logger.error(f"Failed to start application: {str(e)}")
+        sys.exit(1)

docker-compose.yml

@@ -0,0 +1,28 @@
+version: '3.8'
+
+services:
+  traffic-detection:
+    build: .
+    ports:
+      - "7860:7860"
+    volumes:
+      - ./ANPR_IND:/app/ANPR_IND
+      - ./Helmet-Detect-model:/app/Helmet-Detect-model
+      - ./logs:/app/logs
+    environment:
+      - PYTHONUNBUFFERED=1
+      - GRADIO_SERVER_NAME=0.0.0.0
+      - GRADIO_SERVER_PORT=7860
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:7860/api/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu] 

prd.md

@@ -0,0 +1,54 @@
+# Project Progress: Combined ANPR and Helmet Detection System
+
+## Project Status
+- [x] Initial Setup
+  - [x] Created virtual environment
+  - [x] Cloned Helmet Detection repository
+  - [x] Cloned ANPR repository
+
+## Next Steps
+- [x] Dependencies Installation
+  - [x] Created combined requirements.txt with specific versions
+  - [x] Fixed Gradio version to 4.19.2 for compatibility
+  - [x] Installed required Python packages
+  - [x] Verified model files present
+  
+- [x] Integration
+  - [x] Created unified Gradio interface (app.py)
+  - [x] Fixed import paths and module structure
+    - [x] Added __init__.py to scripts directory
+    - [x] Fixed relative imports in ANPR components
+    - [x] Added proper Python path handling
+  - [x] Combined model inference with proper error handling
+  - [x] Added example images with correct absolute paths
+  - [x] Implemented confidence threshold control
+  
+- [x] Testing
+  - [x] Added example test cases
+  - [x] Implemented combined image annotation
+  - [x] Fixed Gradio queue implementation
+  - [x] Added proper error handling for model initialization
+
+## Features
+- Modern Gradio interface with real-time processing
+- Combined ANPR and Helmet detection in single interface
+- Merged visual annotations from both models
+- Adjustable confidence threshold for ANPR
+- Example images from ANPR dataset
+- Comprehensive error handling for both models
+- Queue support for multiple users
+
+## Known Issues
+- None yet
+
+## Updates
+- [2025-02-16] Project initialized, repositories cloned
+- [2025-02-16] Created combined interface with Streamlit
+- [2025-02-16] Installed all required dependencies
+- [2025-02-16] Migrated to Gradio interface with improved features
+- [2025-02-16] Fixed import issues and improved functionality
+- [2025-02-16] Fixed dependency and launch issues:
+  - Updated to Gradio 4.19.2 for compatibility
+  - Fixed queue implementation
+  - Added specific package versions
+  - Improved error handling for initialization

requirements.txt

@@ -0,0 +1,15 @@
+opencv-python-headless==4.8.0.74
+numpy==1.24.3
+Pillow==9.5.0
+gradio==4.19.2
+streamlit==1.24.0
+ultralytics==8.0.196
+python-bidi==0.4.2
+matplotlib==3.7.1
+pandas==2.0.3
+seaborn==0.12.2
+scikit-learn==1.3.0
+fastapi==0.104.1
+uvicorn==0.24.0
+python-multipart==0.0.6
+python-dotenv==1.0.0

run.bat

@@ -0,0 +1,25 @@
+@echo off
+echo Starting Traffic Violation Detection System...
+
+REM Activate virtual environment
+call venv\Scripts\activate
+if errorlevel 1 (
+    echo Failed to activate virtual environment. Please run setup.bat first.
+    pause
+    exit /b 1
+)
+
+REM Start the application
+echo Starting the application...
+python app.py
+if errorlevel 1 (
+    echo Application failed to start. Check app.log for details.
+    pause
+    exit /b 1
+)
+
+REM Deactivate virtual environment
+deactivate
+
+echo Application stopped. Press any key to exit...
+pause 

setup.bat

@@ -0,0 +1,67 @@
+@echo off
+echo Setting up Traffic Violation Detection System...
+
+REM Check if running with admin privileges
+net session >nul 2>&1
+if %errorLevel% == 0 (
+    echo Running with administrator privileges...
+) else (
+    echo Please run this script as administrator
+    echo Right-click on setup.bat and select "Run as administrator"
+    pause
+    exit /b 1
+)
+
+REM Check if Python is installed
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo Python is not installed. Please install Python 3.8 or higher.
+    pause
+    exit /b 1
+)
+
+REM Remove existing venv if it exists
+if exist venv (
+    echo Removing existing virtual environment...
+    rmdir /s /q venv
+)
+
+REM Create new virtual environment
+echo Creating virtual environment...
+python -m venv venv
+
+REM Activate virtual environment
+call venv\Scripts\activate
+
+REM Install/upgrade pip
+python -m pip install --upgrade pip
+
+REM Install requirements with specific torch version
+echo Installing dependencies...
+pip install torch==2.2.0 torchvision==0.17.0 --index-url https://download.pytorch.org/whl/cu118
+pip install -r requirements.txt
+
+REM Create necessary directories if they don't exist
+if not exist ANPR_IND mkdir ANPR_IND
+if not exist Helmet-Detect-model mkdir Helmet-Detect-model
+if not exist logs mkdir logs
+
+REM Check for model files
+if not exist ANPR_IND\licence_plat.pt (
+    echo Warning: ANPR plate detection model not found
+    echo Please ensure licence_plat.pt is in the ANPR_IND directory
+)
+
+if not exist ANPR_IND\licence_character.pt (
+    echo Warning: ANPR character recognition model not found
+    echo Please ensure licence_character.pt is in the ANPR_IND directory
+)
+
+if not exist Helmet-Detect-model\best.pt (
+    echo Warning: Helmet detection model not found
+    echo Please ensure best.pt is in the Helmet-Detect-model directory
+)
+
+echo Setup completed successfully!
+echo Please run run.bat to start the application.
+pause