info.txt

This code is a comprehensive Flask-based web application designed for real-time video monitoring with integrated AI-based detection systems. Let's break down its key components and functionalities:

### 1. Core Features
- **Multi-Feature Detection System**:
  - Restricted Zone Intrusion Detection
  - Fire/Smoke Detection
  - Safety Gear Detection
  - Pose Estimation (for worker safety monitoring)
  - Motion Amplification (for subtle motion analysis)

- **User Management**:
  - Registration/Login system with Flask-Login
  - Session management
  - Role-based access control

- **Alert System**:
  - Visual/audio alerts
  - SMS notifications via Twilio
  - Alert history with frame snapshots

- **complaint Management**:
  - User-submitted complaint with file attachments
  - complaint tracking system

- **Camera Management**:
  - Multiple camera configuration
  - Feature toggling per camera
  - RTSP/Webcam support

### 2. Technical Stack
- **Backend**:
  - Flask web framework
  - SQLAlchemy ORM with multiple databases
  - OpenCV for video processing
  - YOLOv8 models for various detections
  - Twilio integration for SMS alerts

- **Frontend**:
  - HTML templates with Jinja2 rendering
  - Video streaming with multipart MIME type
  - Interactive dashboard

- **Database**:
  - SQLite databases for:
    - User credentials
    - Camera configurations
    - Alert history
    - complaints

### 3. Key Components Breakdown

#### **A. Detection Modules**
- **People Detection** (`people_detection`):
  - Uses YOLOv8n model
  - Restricted zone monitoring
  - Configurable detection regions

- **Fire Detection** (`fire_detection`):
  - Custom trained model (fire.pt)
  - 0.60 confidence threshold
  - Persistent bounding box display

- **Safety Gear Detection** (`gear_detection`):
  - Specialized PPE detection
  - Real-time visual feedback

- **Motion Amplification** (`amp`):
  - Eulerian video magnification
  - Amplifies subtle motions (α=2.5)

#### **B. Core Routes**

1. **Authentication System**:
   ```python
   @app.route('/login', methods=['GET', 'POST'])
   def login():
       # Handles user authentication
       # Integrates with Flask-Login

   @app.route('/register', methods=['GET', 'POST'])
   def register():
       # Manages user registration
       # Password stored in plaintext (needs improvement)
   ```

2. **Video Processing Pipeline**:
   ```python
   def process_frames(camid, region, flag_r_zone, flag_pose_alert, flag_fire, flag_gear, user_id):
       # Main video processing loop
       # Handles multiple detection systems
       # Yields JPEG frames for streaming
   ```

3. **Alert System**:
   ```python
   def add_to_db(results, frame, alert_name, user_id):
       # Database logging with 1-minute cooldown
       # Stores base64 encoded snapshots

   def send_alert_message():
       # Twilio integration for SMS alerts
       # Triggered on fire detection
   ```

#### **C. Database Models**

1. **User Model**:
   ```python
   class User(UserMixin, db.Model):
       # Stores user credentials
       # Relationships with cameras and alerts
   ```

2. **Camera Configuration**:
   ```python
   class Camera(db.Model):
       # Per-camera feature toggles
       # Supports multiple cameras per user
   ```

3. **Alert System**:
   ```python
   class Alert(db.Model):
       # Timestamped alert records
       # Stores JPEG snapshots as BLOB
   ```

### 4. Security Features
- Flask-Login integration
- Session management
- CSRF protection (needs improvement)
- File upload validation
- Environment variable configuration

### 5. Operational Flow
1. User authenticates via web interface
2. Configures camera(s) with desired detection features
3. Video stream processed through selected detectors
4. Detected anomalies trigger:
   - Visual/audio alerts
   - Database logging
   - SMS notifications (for critical events)
5. Users can review historical alerts and submit complaint

### 6. Optimization Opportunities
- **Security**:
  - Implement password hashing
  - Add CSRF protection
  - Secure file upload handling

- **Performance**:
  - Model quantization for faster inference
  - Batch processing of video frames
  - Database connection pooling

- **Features**:
  - Real-time dashboard metrics
  - Camera health monitoring
  - Multi-user support with roles
  - Exportable reports

### 7. Deployment Considerations
- Proper WSGI server configuration (e.g., Gunicorn)
- Reverse proxy setup (Nginx/Apache)
- Database migration to PostgreSQL/MySQL
- Docker containerization
- GPU acceleration for model inference

This system provides a foundation for industrial safety monitoring with AI capabilities. It demonstrates effective integration of computer vision models with web technologies, while maintaining scalability for enterprise-level deployments.