• Overview
• Features
• Architecture
• Technology Stack
• Installation
• Usage
• API Documentation
• Project Structure
• Contributing
• License

DeepVision is a comprehensive AI-powered system designed for underwater image enhancement and threat detection. The platform combines advanced computer vision techniques with modern web technologies to provide real-time image processing, enhancement, and automated threat identification for underwater environments.

• 🔍 Underwater Image Enhancement: AI-powered dehazing and visibility improvement using UNet architecture
• 🎯 Object Detection: YOLO-based detection of underwater threats and objects
• 📧 Real-time Alerts: Automated email notifications for detected threats
• ☁️ Cloud Storage: Integrated Cloudinary storage for processed images
• 📊 Analytics Dashboard: Historical data visualization and system monitoring
• 🔧 Operator Profiles: Configurable alert settings and contact management

• Underwater Image Dehazing: Advanced UNet-based model for improving underwater image clarity
• Object Detection: YOLO v8/v11 models trained for underwater object detection
• Real-time Processing: Fast inference with GPU acceleration support
• Batch Processing: Support for video and image batch processing

• Responsive Design: Mobile-first design with Tailwind CSS
• Real-time Updates: Live processing status and results
• Interactive Dashboard: Comprehensive analytics and historical data
• File Upload: Drag-and-drop image and video upload support

• Automated Notifications: Email alerts for detected threats
• Configurable Settings: Operator profile management
• Threat Classification: Detailed threat detection reporting
• System Logs: Comprehensive logging and monitoring

• Microservices: Modular design with separate services
• Docker Support: Containerized deployment options
• Cloud Integration: Cloudinary for image storage
• Database Integration: MongoDB for data persistence

graph TB
    subgraph "Frontend"
        A[React Client]
        B[Tailwind CSS]
        C[Vite Build System]
    end
    
    subgraph "Backend Services"
        D[Node.js Express Server]
        E[FastAPI Object Detection]
        F[Flask Image Enhancement]
    end
    
    subgraph "AI Models"
        G[YOLO Object Detection]
        H[UNet Image Dehazing]
    end
    
    subgraph "External Services"
        I[Cloudinary Storage]
        J[MongoDB Database]
        K[Email Service]
    end
    
    A --> D
    D --> E
    D --> F
    E --> G
    F --> H
    D --> I
    D --> J
    D --> K

• React 19.1+ - Modern UI library
• Vite - Fast build tool and dev server
• Tailwind CSS - Utility-first CSS framework
• React Router - Client-side routing
• Axios - HTTP client for API calls

• Node.js - JavaScript runtime
• Express.js - Web framework
• FastAPI - Python web framework for object detection
• Flask - Python web framework for image enhancement
• MongoDB - NoSQL database
• Mongoose - MongoDB object modeling

• PyTorch 2.0+ - Deep learning framework
• Ultralytics YOLO - Object detection models
• OpenCV - Computer vision library
• NumPy - Numerical computing
• PIL/Pillow - Image processing

• Docker - Containerization
• Cloudinary - Cloud image/video management
• Nodemailer - Email service
• Multer - File upload handling

• Node.js 18.0 or higher
• Python 3.10 or higher
• MongoDB (local or cloud instance)
• Git

git clone https://github.com/AyushRaj-10/DeepVision.git
cd DeepVision

Create environment files for each service:

# Server/.env
MONGODB_URI=mongodb://localhost:27017/deepvision
CLOUDINARY_CLOUD_NAME=your_cloud_name
CLOUDINARY_API_KEY=your_api_key
CLOUDINARY_API_SECRET=your_api_secret
EMAIL_HOST=smtp.gmail.com
EMAIL_PORT=587
EMAIL_USER=your_email@gmail.com
EMAIL_PASS=your_app_password

# object_detection/.env
HF_TOKEN=your_huggingface_token
HF_USERNAME=your_hf_username

# under-water_imaging-main/.env
FLASK_ENV=production

cd Server
npm install
npm start

cd object_detection
pip install -r requirements.txt
uvicorn app:app --host 0.0.0.0 --port 7860

cd under-water_imaging-main
pip install -r requirements.txt
python app.py

cd Client
npm install
npm run dev

# Build and run object detection service
cd object_detection
docker build -t deepvision-detection .
docker run -p 7860:7860 deepvision-detection

# Build and run image enhancement service
cd under-water_imaging-main
docker build -t deepvision-enhancement .
docker run -p 5000:5000 deepvision-enhancement

1. Start the application by running all services
2. Navigate to http://localhost:5173 (React dev server)
3. Upload an image using the upload button
4. Click "Enhance Image" to process
5. View results including enhanced image and threat detection
6. Configure alerts in the Profile section

curl -X POST http://localhost:3001/api/upload \
  -F "file=@your_image.jpg" \
  -H "Content-Type: multipart/form-data"

curl -X POST http://localhost:7860/detect \
  -F "file=@your_image.jpg"

curl -X POST http://localhost:5000/enhance \
  -F "file=@your_image.jpg"

cd object_detection
python train.py --data data.yaml --epochs 100 --batch-size 16

cd under-water_imaging-main
python train.py --epochs 20 --batch-size 16 --lr 0.0001

Base URL: http://localhost:7860

Base URL: http://localhost:5000

Base URL: http://localhost:3001

DeepVision/
├── Client/                    # React frontend
│   ├── src/
│   │   ├── components/        # Reusable UI components
│   │   ├── pages/            # Page components
│   │   ├── context/          # React context providers
│   │   └── main.jsx          # Application entry point
│   ├── public/               # Static assets
│   └── package.json
├── Server/                   # Node.js backend
│   ├── controllers/          # Request handlers
│   ├── models/              # Database models
│   ├── routes/              # API routes
│   ├── utils/               # Utility functions
│   └── server.js            # Server entry point
├── object_detection/         # YOLO object detection service
│   ├── app.py               # FastAPI application
│   ├── model.py             # YOLO model wrapper
│   ├── train.py             # Training script
│   ├── checkpoints/         # Model weights
│   ├── dataset/             # Training data
│   └── requirements.txt
├── under-water_imaging-main/ # Image enhancement service
│   ├── app.py               # Flask application
│   ├── model.py             # UNet model definition
│   ├── train.py             # Training script
│   ├── checkpoints/         # Model weights
│   └── requirements.txt
└── README.md

We welcome contributions! Please follow these steps:

1. Fork the repository
2. Create a feature branch: git checkout -b feature/amazing-feature
3. Commit your changes: git commit -m 'Add amazing feature'
4. Push to the branch: git push origin feature/amazing-feature
5. Open a Pull Request

• Follow the existing code style
• Add tests for new features
• Update documentation as needed
• Ensure all services start without errors

# Frontend tests
cd Client
npm test

# Backend tests
cd Server
npm test

# Python tests
cd object_detection
python -m pytest

cd under-water_imaging-main
python -m pytest

This project is licensed under the MIT License - see the LICENSE file for details.

• Ultralytics for the YOLO implementation
• PyTorch team for the deep learning framework
• React and Vite teams for the frontend tools
• FastAPI and Flask teams for the Python web frameworks

For support and questions:

• 📧 Email: support@deepvision.ai
• 💬 Discord: DeepVision Community
• 📖 Documentation: Wiki
• 🐛 Issues: GitHub Issues