CoolFace
Apppublic

Siddharthk1/Drone-Detection-Tracking

sourceHugging Faceupdated 5mo agoView on Hugging Face
0likes
App README

🚁 Drone Tracking Web Application

A full-stack real-time drone detection and tracking system built with FastAPI backend and React frontend.

Features

  • —Real-time Video Feed: Live camera stream with drone detection overlay
  • —YOLO + DeepSORT Integration: Advanced object detection and tracking
  • —Real-time Notifications: WebSocket-based instant alerts for new detections
  • —Interactive Dashboard: Modern React UI with Material-UI components
  • —Detection Database: SQLite storage for all detection records
  • —Interactive Map: Leaflet map showing drone detection locations
  • —Statistics Tracking: Daily detection counts and analytics

System Requirements

  • —Python 3.8+
  • —Node.js 16+
  • —Camera/Webcam
  • —YOLO model file (best.pt)

Quick Start

1. Clone and Setup Backend

bash
# Navigate to backend directory
cd backend

# Create virtual environment
python -m venv venv

# Activate virtual environment
# On Windows:
venv\Scripts\activate
# On macOS/Linux:
source venv/bin/activate

# Install dependencies
pip install -r requirements.txt

2. Add Your YOLO Model

Place your trained YOLO model file (best.pt) in the backend directory, or update the MODEL_PATH in main.py:

python
MODEL_PATH = "path/to/your/model.pt"

3. Start Backend Server

bash
# Start FastAPI server
uvicorn main:app --reload --host 0.0.0.0 --port 8000

The backend will be available at: http://localhost:8000

4. Setup Frontend

bash
# Navigate to frontend directory
cd ../frontend

# Install dependencies
npm install

# Start development server
npm run dev

The frontend will be available at: http://localhost:3000

Usage

  1. 1.Start the Application: Open http://localhost:3000 in your browser
  2. 2.Start Camera: Click the "Start Camera" button to begin detection
  3. 3.View Live Feed: Watch the real-time video with detection overlays
  4. 4.Monitor Detections: See new drone alerts and view detection statistics
  5. 5.Check Map: View detection locations on the interactive map
  6. 6.Review Data: Browse today's detections in the data table

API Endpoints

Camera Control

  • —POST /camera/start - Start camera tracking
  • —POST /camera/stop - Stop camera tracking
  • —GET /camera/status - Get camera status

Detections

  • —GET /detections/today - Get today's detections
  • —GET /detections/ - Get all detections (with pagination)
  • —GET /detections/date/{date} - Get detections for specific date
  • —DELETE /detections/{id} - Delete detection

Real-time

  • —GET /video - Video stream endpoint
  • —WebSocket /ws - Real-time updates

System

  • —GET /health - Health check
  • —GET / - API documentation

Project Structure

drone-tracking/
├── backend/
│   ├── main.py              # FastAPI application
│   ├── tracker.py           # DroneTracker class
│   ├── models.py            # Database models
│   ├── database.py          # Database configuration
│   ├── requirements.txt     # Python dependencies
│   └── static/
│       └── index.html       # Backend test page
└── frontend/
    ├── src/
    │   ├── components/      # React components
    │   ├── hooks/          # Custom hooks
    │   ├── services/       # API services
    │   ├── utils/          # Utilities
    │   ├── App.jsx         # Main app component
    │   └── main.jsx        # React entry point
    ├── package.json        # Node dependencies
    └── vite.config.js      # Vite configuration

Deploying to Hugging Face Spaces

This repo is set up for a Docker Space (sdk: docker in the README header). Typical failures were:

  1. 1.Docker build error — libgl1-mesa-glx is not available on current Debian images. The Dockerfile uses libgl1 and related runtime libraries instead.
  2. 2.Runtime: no weights — backend/best.pt is not in the repository (often too large for Git). Use one of:
  3. 3.Space / container variables (Settings → Variables and secrets):
  4. 4.HF_MODEL_REPO — Hugging Face model repo id, e.g. your-username/your-drone-yolo
  5. 5.HF_MODEL_FILE — optional, defaults to best.pt
  6. 6.HF_TOKEN — only if the model repo is private or gated
  7. 7.Or `MODEL_PATH` — absolute path to a weights file inside the container if you bake it into the image.
  8. 8.Or add best.pt under backend/ and ensure it is included in what you push to the Space.

GitHub → Hugging Face sync (optional)

If you use `.github/workflows/sync-to-hub.yml`, add repository secrets (Settings → Secrets and variables → Actions). Do not paste line breaks inside secret values (a trailing Enter is a common cause of Repo id must use alphanumeric chars errors).

Recommended (one id):

  • —HF_TOKEN — Hugging Face token with write access
  • —HF_SPACE_REPO_ID — exactly YourUsername/YourSpaceName (same as in https://huggingface.co/spaces/YourUsername/YourSpaceName)

Alternative (two parts):

  • —HF_TOKEN
  • —HF_USERNAME — namespace only (e.g. SIDDk1)
  • —SPACE_NAME — Space slug only (e.g. Drone-Detection-Tracking), no slash

Create the Space on Hugging Face first (Docker). After a successful sync, the Space rebuilds from the uploaded files.

Configuration

Backend Configuration

Edit backend/main.py to configure:

  • —Model path: MODEL_PATH = "your-model.pt"
  • —Confidence threshold: confidence_threshold=0.5
  • —Database URL: Set DATABASE_URL environment variable

Frontend Configuration

Edit frontend/src/utils/constants.js to configure:

  • —API base URL
  • —WebSocket URL
  • —Map settings
  • —Notification settings

Troubleshooting

Common Issues

Camera not working:

  • —Check camera permissions
  • —Verify camera is not in use by another application
  • —Try different camera index in tracker.py

Model not found:

  • —Ensure best.pt file exists in backend directory
  • —Check file permissions
  • —Verify model format is compatible

Connection issues:

  • —Check if backend is running on port 8000
  • —Verify frontend proxy configuration in vite.config.js
  • —Check firewall settings

WebSocket connection failed:

  • —Ensure both frontend and backend are running
  • —Check browser console for connection errors
  • —Verify WebSocket URL in constants

Performance Tips

  1. 1.Reduce video resolution in tracker.py for better performance
  2. 2.Adjust confidence threshold to reduce false positives
  3. 3.Limit frame rate for lower CPU usage
  4. 4.Use GPU acceleration if available with CUDA

Development

Adding New Features

  1. 1.Backend: Add new endpoints in main.py
  2. 2.Frontend: Create new components in src/components/
  3. 3.Database: Update models in models.py
  4. 4.Real-time: Extend WebSocket handlers

Testing

bash
# Backend tests
cd backend
python -m pytest

# Frontend tests  
cd frontend
npm test

Building for Production

bash
# Build frontend
cd frontend
npm run build

# Deploy backend
cd backend
pip install gunicorn
gunicorn main:app --workers 4 --worker-class uvicorn.workers.UvicornWorker

License

This project is licensed under the MIT License.

Contributing

  1. 1.Fork the repository
  2. 2.Create feature branch
  3. 3.Commit changes
  4. 4.Push to branch
  5. 5.Create Pull Request

Support

For issues and questions:

  • —Check the troubleshooting section
  • —Review API documentation at http://localhost:8000/docs
  • —Create an issue on GitHub

Note: Make sure to replace best.pt with your actual YOLO model file trained for drone detection.