👥 Face Counting — Automated Head Count from Group Photos

A computer vision application that automatically detects and counts the number of human faces in a group photo or selfie — built using deep learning-based object detection and deployed as a Flask web app.

---

📌 Problem Statement

Manually counting people in photos is slow, error-prone, and impossible to scale. This project tackles the People Detection and Head Counting challenge — a classical yet demanding computer vision problem with real-world applications across crowd management, event safety, and retail analytics.

Given any group photo or selfie, the system:

1. Detects all human faces in the image automatically
2. Counts the total number of faces with a bounding box drawn around each
3. Returns the final count instantly via a web interface

This project was built as part of a hackathon computer vision challenge — testing skills in deep learning and object detection.

---

🎯 Real-World Applications

Domain	Use Case
Event Management	Auto-count attendees from event photos
Retail Analytics	Count footfall in store snapshots
Security & Surveillance	Crowd density estimation in public spaces
Education	Automated attendance tracking from classroom photos
Social Media	Auto-tag count for group selfies
Public Safety	Crowd control — detect overcrowding at venues

---

🧠 How It Works

The system uses deep learning-based face detection to locate every face in an image, regardless of size, angle, or lighting conditions:

Input Image (Group Photo / Selfie)
        ↓
  Face Detection Model
  (Deep Learning / OpenCV)
        ↓
  Bounding Boxes Drawn
  Around Each Face
        ↓
  Total Face Count Returned

The key challenge in head counting is detecting small, partially occluded, or tilted faces in dense group photos — a much harder problem than single-face detection.

---

🏗️ Project Architecture

Face-Counting/
├── static/
│   └── style.css                # Flask frontend styling
├── templates/
│   └── index.html               # Web app interface
├── uploads/                     # Temporary storage for uploaded images
├── Face Counting.ipynb          # Development & experimentation notebook
├── app.py                       # Flask application (main entry point)
├── requirements.txt             # Python dependencies
├── Procfile                     # Heroku deployment config
└── README.md

---

🔍 Technical Approach

Face Detection Pipeline

Step 1 — Image Input

• Accept image uploads via the Flask web interface
• Support common formats: JPG, JPEG, PNG

Step 2 — Preprocessing

• Resize image for optimal detection performance
• Convert to appropriate colour space (RGB/BGR as required by the model)

Step 3 — Face Detection

• Apply deep learning-based face detector to locate all faces
• Each detected face returns a bounding box (x, y, width, height) with a confidence score
• Filter detections by confidence threshold to reduce false positives

Step 4 — Annotation & Counting

• Draw bounding boxes around each detected face
• Count total number of valid detections
• Return annotated image + count to the user

Why Deep Learning over Traditional Methods?

Approach	Method	Limitation
Traditional	Haar Cascades (Viola-Jones)	Poor on tilted, small, or occluded faces
Deep Learning ✅	CNN-based detector	Handles varied poses, sizes, lighting

Deep learning-based detection significantly outperforms traditional Haar cascade methods, especially in dense group photos where faces may be small, partially covered, or at various angles.

---

🛠️ Tech Stack

Category	Tools
Language	Python 3.7+
Computer Vision	OpenCV
Deep Learning	DeepFace / CNN-based detection
Image Processing	PIL / Pillow, NumPy
Web Framework	Flask
Frontend	HTML, CSS
Deployment	Heroku → Render
Notebook	Jupyter Notebook

---

🚀 Running Locally

# Clone the repository
git clone https://github.com/vicky60629/Face-Counting.git
cd Face-Counting

# Install dependencies
pip install -r requirements.txt

# Run the Flask app
python app.py

Open http://localhost:5000 in your browser.

---

🖥️ How to Use the App

1. Open the web app in your browser
2. Upload a group photo or selfie (JPG/PNG)
3. Click "Count Faces"
4. View the annotated image with bounding boxes drawn around every detected face
5. See the total face count displayed instantly

Example:

Input	Output
Group selfie with 8 people	✅ 8 faces detected — bounding boxes drawn on each
Crowd photo with partial faces	✅ Detects even partially visible faces

---

📈 Key Challenges & How They Were Solved

Challenge	Solution
Small faces in large group photos	Deep learning model trained on varied scales
Partially occluded faces	CNN features capture partial face patterns
Varied lighting conditions	Preprocessing normalisation before detection
Multiple overlapping faces	Non-Maximum Suppression (NMS) to avoid double-counting
Different face angles / poses	Model trained on diverse multi-angle datasets

---

💡 Key Learnings & Future Improvements

What worked well:

• Deep learning-based detection significantly outperforms Haar cascades on group photos
• Flask made it easy to wrap the CV pipeline into an accessible web app
• Confidence threshold tuning was critical — too low causes false positives, too high misses small faces

Future enhancements:

• Add real-time video stream face counting via webcam
• Integrate YOLOv8 for faster, more accurate detection
• Build a crowd density heatmap overlay to show where faces are clustered
• Add age & gender estimation per detected face using DeepFace
• Deploy on Render with a permanent live demo link
• Extend to multi-frame video — count unique individuals across frames (de-duplicate repeated faces)
• Add emotion detection overlay on each bounding box

---

🔬 Computer Vision Context

Face counting sits at the intersection of two active research areas:

Object Detection — locating and bounding instances of objects (here: faces) within images. Modern detectors like YOLO and RetinaNet achieve near-human accuracy on standard benchmarks.

Crowd Counting — estimating the number of people in dense scenes. Goes beyond simple detection — at extreme densities, individual face detection fails and density map estimation is used instead (e.g., CSRNet, MCNN). This project's approach works well for small-to-medium group sizes (2–50 people).

---

👨‍💻 About the Author

Vicky Gupta — Data Engineering Analyst @ Accenture (4.5 years) | Aspiring Data Scientist

Passionate about computer vision, NLP, and building end-to-end ML systems. Experienced in PySpark, ETL pipelines, and deploying ML models from notebook to production.

🔗 LinkedIn | GitHub

📧 vg60629@gmail.com

---

📄 License

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

---

⭐ Found this useful? Star the repository to help others discover it!