🤟 Hand Sign Language Detection System

📌 Project Overview

The Hand Sign Language Detection System is a real-time computer vision application that recognizes American Sign Language (ASL) alphabet gestures from a webcam feed.

The project utilizes a custom-trained Deep Learning model developed using Google's Teachable Machine and integrates OpenCV, TensorFlow/Keras, and CVZone for hand detection and classification.

The system can accurately identify hand signs representing the English alphabets A–Z and display the predicted character in real time.

🚀 Features

Real-time hand gesture recognition
Supports all 26 English alphabet signs (A-Z)
Live webcam prediction
Deep Learning based classification
Automatic hand detection and cropping
Aspect ratio preservation during preprocessing
Bounding box visualization
Predicted label display on screen
Dataset collection utility
Lightweight and easy to deploy

🛠️ Technologies Used

Technology	Purpose
Python	Core Programming Language
OpenCV	Image Processing & Webcam Access
TensorFlow / Keras	Deep Learning Model
Teachable Machine	Model Training
CVZone	Hand Tracking Module
NumPy	Numerical Operations
Math Library	Image Scaling Calculations

📂 Project Structure

Hand-Sign-Detection/
│
├── Data/
│   ├── A/
│   ├── B/
│   ├── C/
│   └── ...
│
├── Model/
│   ├── keras_model.h5
│   └── labels.txt
│
├── dataCollection.py
├── test.py
├── requirements.txt
└── README.md

📖 How It Works

Step 1: Hand Detection

The webcam continuously captures frames.

CVZone's HandDetector identifies the hand and extracts the bounding box coordinates.

hands, img = detector.findHands(img)

Step 2: Hand Cropping

The detected hand region is cropped with additional padding.

imgCrop = img[y-offset:y+h+offset,
              x-offset:x+w+offset]

This ensures the entire hand remains inside the cropped image.

Step 3: Image Normalization

The cropped image is resized and centered on a 300×300 white canvas.

This maintains aspect ratio and improves prediction consistency.

Step 4: Deep Learning Prediction

The processed image is passed to the trained Teachable Machine model.

prediction, index = classifier.getPrediction(imgWhite)

The model returns:

Prediction probabilities
Predicted class index

Step 5: Display Result

The predicted alphabet is displayed on the screen.

cv2.putText(
    imgOutput,
    labels[index],
    (x, y-26),
    cv2.FONT_HERSHEY_COMPLEX,
    2,
    (255,255,255),
    2
)

🧠 Model Information

Training Platform

Google Teachable Machine

Model Type

Image Classification

Framework

TensorFlow / Keras

Output Classes

26 Classes

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

Model File

keras_model.h5

Label File

labels.txt

📸 Dataset Collection

The project includes a dedicated dataset generation script.

Run

python dataCollection.py

Controls

Press:

to save the current hand image.

Captured images are stored automatically in the selected class folder.

Example:

Data/E/

🎯 Prediction Script

Run:

python test.py

The webcam will open and start recognizing hand signs in real time.

⚙️ Installation

Clone Repository

git clone https://github.com/7vik2005/Hand-Sign-Detection.git

cd hand-sign-detection

Create Virtual Environment

Windows

python -m venv venv

venv\Scripts\activate

Linux / Mac

python3 -m venv venv

source venv/bin/activate

Install Dependencies

pip install -r requirements.txt

📦 Requirements

opencv-python
cvzone
numpy
tensorflow
keras
mediapipe

Install manually:

pip install opencv-python cvzone numpy tensorflow keras mediapipe

🖥️ System Requirements

Minimum

Intel i3 Processor
4GB RAM
Webcam
Python 3.8+

📊 Future Enhancements

Word formation from multiple signs
Sentence generation
Voice output using Text-to-Speech
Mobile deployment
Web deployment using Flask
Gesture history tracking
Support for numbers and symbols
Transformer-based sign recognition
Real-time translation system

🔬 Applications

Sign Language Education
Accessibility Solutions
Human Computer Interaction
Smart Learning Systems
Assistive Technologies
Healthcare Communication
Educational Institutions

📈 Performance Goals

The system aims to achieve:

High real-time inference speed
Low latency predictions
Robust hand tracking
Accurate alphabet classification

Performance depends on:

Lighting conditions
Camera quality
Hand visibility
Training dataset quality

🤝 Contributing

Contributions are welcome.

Steps:

Fork the repository
Create a new branch

git checkout -b feature-name

Commit changes

git commit -m "Added new feature"

Push

git push origin feature-name

Open Pull Request

📜 License

This project is licensed under the MIT License.

Feel free to use, modify, and distribute for educational and research purposes.

👨‍💻 Author

Satvik Jambagi

Computer Science Engineering Student

Passionate about:

Artificial Intelligence
Machine Learning
Computer Vision
Deep Learning
Full Stack Development

⭐ Support

If you found this project useful:

⭐ Star the repository

🍴 Fork the project

📢 Share it with others

"Technology becomes meaningful when it makes communication accessible to everyone."

Name		Name	Last commit message	Last commit date
Latest commit History 3 Commits
Model		Model
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
dataCollection.py		dataCollection.py
requirements.txt		requirements.txt
test.py		test.py

Folders and files

Latest commit

History

Repository files navigation