johnwesley756/instance-segmentation

🦷 Tooth Decay Detection and Severity Analysis Using Deep Learning

A computer vision project that uses YOLOv8 to detect dental conditions like tooth, caries, and cavity from images. The application features a FastAPI backend for API-based inference and a Streamlit frontend for interactive testing.

📌 Features

• —⚡ Real-time detection of tooth, caries, and cavity
• —📊 Severity classification (Tooth → Caries → Cavity)
• —📝 Natural language summary for each detection
• —🔌 REST API for integration with other applications
• —🌐 Streamlit UI for easy testing and visualization
• —🐳 Docker support for easy deployment
• —☁️ Hugging Face Spaces ready

🏗️ Architecture

┌─────────────────┐         ┌──────────────────┐
│   Streamlit UI  │ ──HTTP──▶│   FastAPI Server │
│   (Frontend)    │         │    (Backend)     │
│   Port: 7860    │         │    Port: 8000    │
└─────────────────┘         └──────────────────┘
                                     │
                                     ▼
                            ┌─────────────────┐
                            │  YOLOv8 Model   │
                            │    (best.pt)    │
                            └─────────────────┘

🔧 Technologies Used

• —Python 3.11+
• —YOLOv8 / Ultralytics - Object detection model
• —FastAPI - REST API backend
• —Streamlit - Interactive frontend
• —OpenCV - Image processing
• —Docker - Containerization

📁 Project Structure

📦 Instance-segmentation
 ┣ 📜 api.py                 # FastAPI backend server
 ┣ 📜 app.py                 # Streamlit frontend
 ┣ 📜 train_model.py         # Original Streamlit app (legacy)
 ┣ 📜 best.pt                # YOLOv8 trained model
 ┣ 📜 requirements.txt       # Python dependencies
 ┣ 📜 Dockerfile             # Docker configuration
 ┣ 📜 start.sh               # Linux/Mac startup script
 ┣ 📜 start.bat              # Windows startup script
 ┗ 📜 README.md              # This file

🚀 Quick Start

Option 1: Local Development

1. 1.Install dependencies

pip install -r requirements.txt

1. 1.Start the FastAPI backend

uvicorn api:app --host 0.0.0.0 --port 8000

1. 1.Start the Streamlit frontend (in a new terminal)

streamlit run app.py --server.port 7860

1. 1.Access the application
2. 2.Streamlit UI: http://localhost:7860
3. 3.FastAPI Docs: http://localhost:8000/docs

Option 2: Using Startup Scripts

Windows:

start.bat

Linux/Mac:

chmod +x start.sh
./start.sh

Option 3: Docker

1. 1.Build the Docker image

docker build -t tooth-detection .

1. 1.Run the container

docker run -p 7860:7860 -p 8000:8000 tooth-detection

🔌 API Endpoints

GET /

Root endpoint with API information

GET /health

Health check endpoint

{
  "status": "healthy",
  "model_loaded": true,
  "model_path": "best.pt"
}

POST /predict

Upload an image for tooth decay detection

Request:

• —Method: POST
• —Content-Type: multipart/form-data
• —Body: file (image file)

Response:

{
  "success": true,
  "severity": "Caries",
  "summary": "Caries (initial decay) detected...",
  "detections": [
    {
      "class": "caries",
      "confidence": 0.856,
      "bbox": [120.5, 45.2, 280.3, 190.7]
    }
  ],
  "total_detections": 1,
  "annotated_image": "base64_encoded_image..."
}

Example using cURL:

curl -X POST "http://localhost:8000/predict" \
  -F "file=@dental_image.jpg"

Example using Python:

import requests

url = "http://localhost:8000/predict"
files = {"file": open("dental_image.jpg", "rb")}
response = requests.post(url, files=files)
print(response.json())

✅ Severity Logic

🌐 Deploying to Hugging Face Spaces

1. 1.Create a new Space on Hugging Face
2. 2.Choose "Docker" as the SDK

1. 1.Upload files:
2. 2.api.py
3. 3.app.py
4. 4.best.pt
5. 5.requirements.txt
6. 6.Dockerfile
7. 7.start.sh

1. 1.The Space will automatically build and deploy

1. 1.Access your deployed app at:
2. 2.https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME

🧪 Testing the Model

1. 1.Upload a dental X-ray or intraoral image
2. 2.The model will detect and classify:
3. 3.Tooth: Healthy teeth
4. 4.Caries: Early-stage decay
5. 5.Cavity: Advanced decay
6. 6.View the annotated image with bounding boxes
7. 7.Read the severity level and summary

🧠 Future Enhancements

• —Add authentication for API access
• —Implement batch processing for multiple images
• —Add model versioning and A/B testing
• —Create mobile app using the API
• —Add real-time webcam detection
• —Integrate with dental clinic management systems

📄 License

This project is for educational and research purposes.

👨‍💻 Developer

Built with ❤️ using YOLOv8, FastAPI, and Streamlit