Skip to content

Juniorc027/Reconhecimento-Facial

Repository files navigation

🎯 Sistema de Reconhecimento Facial Profissional

Versão: 2.0
Status: Em Desenvolvimento Ativo
Última Atualização: 29 de Novembro de 2025


🚀 Visão Geral

Sistema completo de Reconhecimento Facial para controle de acesso, registro de ponto e automação IoT, desenvolvido com arquitetura profissional e tecnologias de ponta.

🎯 Objetivos do Projeto

1. Controle de Acesso (Atual - Sprints 1-6)

  • Reconhecimento facial para autenticação
  • Registro de ponto biométrico
  • Dashboard de monitoramento em tempo real

2. Monitoramento (Futuro - Sprint 7+)

  • Reconhecimento facial em tempo real
  • Alertas e notificações automáticas

3. Integração IoT (Futuro - Sprint 8+)

  • Abertura automática de portões
  • Integração com ESP32/Raspberry Pi
  • Automações personalizadas

4. Cloud Deployment (Futuro - Sprint 10)

  • Sistema online em Azure/AWS
  • Escalabilidade global
  • Alta disponibilidade

🏗️ Arquitetura

┌─────────────────────────────────────────────────────────┐
│         FACIAL RECOGNITION SYSTEM v2.0                  │
└─────────────────────────────────────────────────────────┘
                        │
       ┌────────────────┼────────────────┐
       │                │                │
  ┌────▼────┐     ┌────▼────┐     ┌────▼────┐
  │Backend  │     │Python   │     │Frontend │
  │C# .NET 8│────▶│FastAPI  │◀────│Blazor   │
  │Clean    │     │YOLO+ML  │     │Server   │
  │Arch     │     │ONNX     │     │Real-Time│
  └────┬────┘     └────┬────┘     └────┬────┘
       │               │               │
       └───────┬───────┴───────┬───────┘
               │               │
          ┌────▼────┐     ┌───▼────┐
          │ MySQL   │     │ Redis  │
          │ 8.0     │     │ Cache  │
          └─────────┘     └────────┘
               │
          ┌────▼────┐
          │  MQTT   │
          │ Broker  │
          └─────────┘

Stack Tecnológica

Backend:

  • C# (.NET 8) - Clean Architecture
  • Entity Framework Core 8
  • ASP.NET Core Web API
  • Microsoft.ML.OnnxRuntime

IA/ML:

  • Python 3.11 + FastAPI
  • YOLOv8 (detecção facial)
  • ArcFace (embeddings faciais)
  • ONNX Runtime (inferência)

Frontend:

  • Blazor Server (.NET 8)
  • SignalR (tempo real)
  • Bootstrap 5

Infraestrutura:

  • Docker + Docker Compose
  • MySQL 8.0
  • Redis 7
  • MQTT (Eclipse Mosquitto)

Monitoring:

  • Prometheus
  • Grafana
  • Serilog

📚 Documentação

🎯 Comece Aqui

Documento Descrição Quando Usar
INDICE-GERAL.md Índice de toda documentação Primeiro contato
RESUMO-EXECUTIVO.md Overview completo do projeto Visão geral
GUIA-SETUP-EXECUCAO.md Setup e execução passo a passo Rodar o projeto
ROADMAP-CONTINUACAO.md Planejamento futuro (Sprints 5-10) Entender próximos passos

📖 Documentação Técnica

Documento Conteúdo
ESTRUTURA-DEFINITIVA.md Arquitetura e diretórios
PROMPTS-DESENVOLVIMENTO.md 50+ prompts para gerar código
PROJECT_STATUS.md Estado atual (histórico)

🐳 Configurações

Arquivo Descrição
docker-compose-v2.yml Orquestração completa
Dockerfile.backend Container C#
Dockerfile.python Container Python

⚡ Quick Start

Pré-requisitos

# Verificar ferramentas instaladas
docker --version          # >= 24.0
docker-compose --version  # >= 2.20
dotnet --version          # >= 8.0
python --version          # >= 3.11

Setup em 5 Passos

1. Clone o Repositório

git clone https://github.com/seu-usuario/FacialRecognitionSystem.git
cd FacialRecognitionSystem

2. Configure Variáveis de Ambiente

cp .env.example .env
# Editar .env conforme necessário

3. Setup Python ML

cd python-ml
python -m venv venv
.\venv\Scripts\activate
pip install -r requirements.txt

# Download modelos pré-treinados
python scripts/download_models.py

4. Iniciar com Docker

cd ..
docker-compose -f docker-compose-v2.yml --profile dev up

5. Acessar Sistema

✅ Backend API:    http://localhost:5000/swagger
✅ Python ML API:  http://localhost:8000/docs
✅ Adminer (DB):   http://localhost:8080
✅ Grafana:        http://localhost:3001 (se ativo)

📖 Para instruções detalhadas, veja: GUIA-SETUP-EXECUCAO.md


🧪 Testar Reconhecimento Facial

1. Cadastrar Usuário

curl -X POST "http://localhost:5000/api/users" `
  -H "Content-Type: application/json" `
  -d '{
    "name": "John Doe",
    "email": "john.doe@company.com",
    "cpf": "12345678900",
    "password": "Password@123"
  }'

2. Registrar Face

curl -X POST "http://localhost:5000/api/facerecognition/register" `
  -F "userId=GUID_DO_USUARIO" `
  -F "photo=@caminho/para/foto.jpg"

3. Reconhecer Face

curl -X POST "http://localhost:5000/api/facerecognition/recognize" `
  -F "photo=@caminho/para/foto.jpg"

Resposta esperada:

{
  "isRecognized": true,
  "userId": "guid-do-usuario",
  "userName": "John Doe",
  "confidenceScore": 0.95,
  "processingTimeMs": 450
}

📂 Estrutura do Projeto

FacialRecognitionSystem/
├── 📂 backend-csharp/          # Backend C# (.NET 8)
│   └── src/
│       ├── Domain/             # Entidades, Value Objects
│       ├── Application/        # Use Cases, DTOs
│       ├── Infrastructure/     # Repositories, ONNX
│       ├── API/                # Controllers REST
│       └── WebUI/              # Blazor Server
│
├── 📂 python-ml/               # Microserviço Python
│   ├── api/                    # FastAPI routes
│   ├── core/                   # YOLO, ArcFace
│   ├── training/               # Scripts de treino
│   ├── export/                 # Conversão ONNX
│   └── models/                 # Modelos ONNX
│
├── 📂 iot-devices/             # IoT (futuro)
│   ├── esp32-firmware/
│   └── simulator/
│
├── 📂 infra/                   # Infraestrutura
│   ├── docker/                 # Dockerfiles
│   ├── kubernetes/             # K8s manifests
│   ├── mysql/                  # Scripts SQL
│   └── mqtt/                   # Configurações MQTT
│
└── 📂 docs/                    # Documentação

🗓️ Roadmap

✅ Concluído

  • Arquitetura definida
  • MVP simplificado funcional
  • Docker configurado
  • Documentação completa

🔄 Em Progresso

  • Sprint 5: Integração IA Real (Semana 7)
    • Setup Python environment
    • Download modelos YOLO + ArcFace
    • Conversão para ONNX
    • Integração C# ↔ ONNX

📅 Próximas Sprints

Sprint Objetivo Duração Status
Sprint 5 IA Real (YOLO + ArcFace) 15-20h 🔄 Atual
Sprint 6 Frontend Blazor Completo 25-30h ⏭️ Próximo
Sprint 7 Microserviço Python 15-20h 📋 Planejado
Sprint 8 IoT & MQTT 20-25h 📋 Planejado
Sprint 9 Segurança & Otimizações 25-30h 📋 Planejado
Sprint 10 Deploy Cloud 25-35h 📋 Planejado

Total: 125-160 horas (6 semanas)

📖 Ver roadmap completo: ROADMAP-CONTINUACAO.md


🎯 Features Principais

✅ Implementado

  • ✅ API REST completa (Users, Devices, AccessLogs)
  • ✅ Mock AI service (simulação realística)
  • ✅ Entity Framework com InMemory DB
  • ✅ Swagger/OpenAPI documentation
  • ✅ Docker Compose com bind mounts
  • ✅ Health checks

🔄 Em Desenvolvimento

  • 🔄 Integração YOLO real
  • 🔄 Integração ArcFace real
  • 🔄 Pipeline ONNX completo

📋 Planejado

  • 📋 Frontend Blazor com webcam
  • 📋 Dashboard em tempo real
  • 📋 Microserviço Python isolado
  • 📋 MQTT broker para IoT
  • 📋 Automação de portões
  • 📋 Deploy em cloud (Azure/AWS)

🛠️ Comandos Úteis

Docker

# Desenvolvimento completo
docker-compose -f docker-compose-v2.yml --profile dev up

# Com monitoramento
docker-compose -f docker-compose-v2.yml --profile dev --profile monitoring up

# Rebuild sem cache
docker-compose -f docker-compose-v2.yml build --no-cache

# Ver logs
docker-compose -f docker-compose-v2.yml logs -f backend
docker-compose -f docker-compose-v2.yml logs -f python-ml

# Parar tudo
docker-compose -f docker-compose-v2.yml down

# Limpar volumes
docker-compose -f docker-compose-v2.yml down -v

Backend C#

cd backend-csharp

# Restore dependencies
dotnet restore

# Build
dotnet build

# Run API
cd src/API
dotnet run

# Run with hot reload
dotnet watch run

# Run tests
dotnet test

Python ML

cd python-ml

# Ativar venv
.\venv\Scripts\activate  # Windows
source venv/bin/activate  # Linux/Mac

# Instalar dependencies
pip install -r requirements.txt

# Run FastAPI
uvicorn api.main:app --reload

# Treinar YOLO
python training/train_yolo.py --dataset datasets/faces --epochs 100

# Converter para ONNX
python export/export_to_onnx.py --model yolo --input models/pretrained/yolov8n.pt --output models/exported/yolo_face.onnx

📊 Performance

Targets

  • ✅ Reconhecimento: <500ms
  • ✅ Acurácia: >95%
  • ✅ Throughput: 100+ req/s
  • ✅ Uptime: 99.9%

Hardware Recomendado

  • CPU: 8+ cores
  • RAM: 16 GB
  • GPU: NVIDIA GTX 1660+ (opcional mas recomendado)
  • Storage: 100 GB NVMe SSD

🤝 Contribuindo

Setup para Desenvolvimento

  1. Fork o projeto
  2. Clone seu fork
  3. Siga o GUIA-SETUP-EXECUCAO.md
  4. Crie branch feature (git checkout -b feature/nova-funcionalidade)
  5. Commit mudanças (git commit -m 'feat: adiciona funcionalidade X')
  6. Push para branch (git push origin feature/nova-funcionalidade)
  7. Abra Pull Request

Padrões de Código

  • C#: Clean Code, SOLID principles
  • Python: PEP 8, type hints
  • Commits: Conventional Commits
  • Testes: Cobertura >80%

📄 Licença

Este projeto está licenciado sob a MIT License - veja o arquivo LICENSE para detalhes.


📞 Suporte

Documentação

Issues

  • 🐛 Reporte bugs via GitHub Issues
  • 💡 Sugestões de features via GitHub Discussions

🎉 Status do Projeto

Sprint 0-4:  ████████████████████████████████ 100% ✅ Concluído
Sprint 5:    ████████░░░░░░░░░░░░░░░░░░░░░░░░  25% 🔄 Em progresso
Sprint 6-10: ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░   0% 📋 Planejado

Próximo marco: Integração IA Real (Sprint 5) - Previsão: Fim da Semana 7


🌟 Destaques

Arquitetura Clean: Separação clara de responsabilidades
IA State-of-the-art: YOLO + ArcFace via ONNX
Microserviços: Backend C# + Python ML isolados
Tempo Real: SignalR para atualizações instantâneas
Escalável: Preparado para cloud e kubernetes
IoT Ready: MQTT integrado para dispositivos


Desenvolvido com ❤️ para reconhecimento facial profissional


Última atualização: 29/11/2025
Versão: 2.0
Maintainer: Sistema de Desenvolvimento de IA

About

No description, website, or topics provided.

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

 
 
 

Contributors