Documentação e melhorias no Examples

README.md

@@ -14,14 +14,18 @@ resources:
   gpu: true
 ---
 
-# Detector de Riscos em Vídeo
+Sistema de detecção de objetos de risco em vídeos usando OWL-ViT e processamento
+GPU/CPU otimizado.
 
-Sistema de detecção de objetos de risco em vídeos usando OWL-ViT e processamento GPU/CPU otimizado.
+[![Open in Hugging Face][hf-badge]][hf-space]
+[![GitHub][gh-badge]][gh-repo]
 
-[![Open in Hugging Face](https://img.shields.io/badge/Hugging%20Face-Spaces-yellow)](https://huggingface.co/spaces/seu-usuario/seu-espaco)
-[![GitHub](https://img.shields.io/badge/GitHub-Repo-blue)](https://github.com/seu-usuario/hackatoon-1iadt)
+[hf-badge]: https://img.shields.io/badge/Hugging%20Face-Spaces-yellow
+[hf-space]: https://huggingface.co/spaces/seu-usuario/seu-espaco
+[gh-badge]: https://img.shields.io/badge/GitHub-Repo-blue
+[gh-repo]: https://github.com/seu-usuario/hackatoon-1iadt
 
-## 🚀 Funcionalidades
+## Funcionalidades
 
 - Detecção de objetos de risco em vídeos
 - Processamento otimizado em GPU (NVIDIA T4) e CPU
@@ -30,58 +34,63 @@ Sistema de detecção de objetos de risco em vídeos usando OWL-ViT e processame
 - Suporte a webhooks para notificações
 - Métricas detalhadas de processamento
 
-## 📋 Requisitos
+## Requisitos
 
 - Python 3.10+
 - CUDA 11.8+ (para GPU)
 - NVIDIA T4 16GB ou superior (recomendado)
 - 16GB RAM mínimo
 
-## 🔧 Instalação
+## Instalação
 
 1. Clone o repositório:
-```bash
-git clone https://github.com/seu-usuario/hackatoon-1iadt.git
-cd hackatoon-1iadt
-```
+
+    ```bash
+    git clone https://github.com/seu-usuario/hackatoon-1iadt.git
+    cd hackatoon-1iadt
+    ```
 
 2. Instale as dependências:
-```bash
-pip install -r requirements.txt
-```
+
+    ```bash
+    pip install -r requirements.txt
+    ```
 
 3. Configure o ambiente:
-```bash
-cp .env.example .env
-```
+
+    ```bash
+    cp .env.example .env
+    ```
 
 [Documentação completa de instalação](docs/setup/installation.md)
 
-## 💻 Uso
+## Uso
 
 1. Inicie a aplicação:
-```bash
-python app.py
-```
 
-2. Acesse: http://localhost:7860
+    ```bash
+    python app.py
+    ```
+
+2. Acesse: `http://localhost:7860`
 
 3. Upload de vídeo:
-   - Arraste ou selecione um vídeo
-   - Ajuste as configurações
-   - Clique em "Detectar"
 
-## 📚 Documentação
+    - Arraste ou selecione um vídeo
+    - Ajuste as configurações
+    - Clique em "Detectar"
+
+## Documentação
 
 - [Arquitetura do Sistema](docs/architecture/overview.md)
 - [Instalação e Configuração](docs/setup/installation.md)
 - [API e Interface](docs/api/interface.md)
 
-## 🏗️ Arquitetura
+## Arquitetura
 
 O projeto segue os princípios da Clean Architecture:
 
-```
+```plaintext
 src/
 ├── domain/         # Regras de negócio
 ├── application/    # Casos de uso
@@ -91,54 +100,56 @@ src/
 
 [Detalhes da arquitetura](docs/architecture/overview.md)
 
-## 🚀 Deploy no Hugging Face
+## Deploy no Hugging Face
 
 1. Configure as credenciais:
-```bash
-cp .env.example .env.huggingface
-```
+
+    ```bash
+    cp .env.example .env.huggingface
+    ```
 
 2. Execute o deploy:
-```bash
-./deploy.sh
-```
 
-[Instruções detalhadas de deploy](docs/setup/installation.md#deployment-no-hugging-face)
+    ```bash
+    ./deploy.sh
+    ```
 
-## 💪 Máquinas Recomendadas
+## Máquinas Recomendadas
 
 ### GPU
+
 - NVIDIA T4 16GB (Hugging Face Pro)
 - NVIDIA A100 (Performance máxima)
 - NVIDIA V100 (Alternativa)
 
 ### CPU
+
 - 8+ cores
 - 32GB+ RAM
 - SSD para armazenamento
 
-## 🔍 Interface
+## Interface
 
 ### Componentes
+
 - Upload de vídeo (MP4, AVI, MOV)
 - Configurações de detecção
 - Visualização de resultados
 - Métricas em tempo real
 
-[Documentação da interface](docs/api/interface.md)
-
-## 🔗 Links
+## Links
 
-- [Hugging Face Space](https://huggingface.co/spaces/seu-usuario/seu-espaco)
-- [GitHub Repository](https://github.com/seu-usuario/hackatoon-1iadt)
+- [Hugging Face Space][hf-space]
+- [GitHub Repository][gh-repo]
 - [Documentação](docs/)
 - [Issues](https://github.com/seu-usuario/hackatoon-1iadt/issues)
 
-## 📄 Licença
+## Licença
 
-Este projeto está licenciado sob a MIT License - veja o arquivo [LICENSE](LICENSE) para detalhes.
+Este projeto está licenciado sob a MIT License - veja o arquivo [LICENSE](LICENSE)
+para detalhes.
 
-## 👥 Contribuição
+## Contribuição
 
 1. Fork o projeto
 2. Crie sua feature branch (`git checkout -b feature/AmazingFeature`)
@@ -146,11 +157,8 @@ Este projeto está licenciado sob a MIT License - veja o arquivo [LICENSE](LICEN
 4. Push para a branch (`git push origin feature/AmazingFeature`)
 5. Abra um Pull Request
 
-## 📞 Suporte
+## Suporte
 
 - Abra uma [issue](https://github.com/seu-usuario/hackatoon-1iadt/issues)
 - Consulte a [documentação](docs/)
 - Entre em contato com a equipe
-
----
-Desenvolvido com ❤️ para o Hackathon FIAP

docs/api/interface.md

@@ -1,6 +1,6 @@
 # Interface e API
 
-## Interface Web (Gradio)
+## Interface Web
 
 ### Componentes Principais
 
@@ -64,7 +64,7 @@ Content-Type: multipart/form-data
                 {
                     "label": "arma",
                     "confidence": 95.5,
-                    "bbox": [x1, y1, x2, y2]
+                    "bbox": [0, 0, 100, 100]
                 }
             ]
         }

docs/architecture/overview.md

@@ -7,41 +7,49 @@ O sistema de detecção de riscos em vídeo é construído seguindo os princípi
 ## Camadas da Arquitetura
 
 ### 1. Domain (Núcleo)
+
 - Contém as regras de negócio e entidades fundamentais
 - Independente de frameworks e bibliotecas externas
 - Localização: `src/domain/`
 
-#### Componentes Principais:
+#### Componentes Principais
+
 - `detectors/`: Implementações dos detectores (GPU/CPU)
 - `entities/`: Objetos de domínio
 - `factories/`: Fábricas para criação de objetos
 - `interfaces/`: Contratos e interfaces
 
 ### 2. Application
+
 - Implementa os casos de uso da aplicação
 - Orquestra o fluxo de dados entre as camadas
 - Localização: `src/application/`
 
-#### Casos de Uso:
+#### Casos de Uso
+
 - `process_video`: Processamento e análise de vídeos
 - Notificações de detecções
 - Gerenciamento de cache
 
 ### 3. Infrastructure
+
 - Implementações concretas de interfaces
 - Integrações com serviços externos
 - Localização: `src/infrastructure/`
 
-#### Serviços:
+#### Serviços
+
 - `WeaponDetectorService`: Serviço principal de detecção
 - `NotificationService`: Serviço de notificações
 - Gerenciamento de GPU/CPU
 
 ### 4. Presentation
+
 - Interface com usuário via Gradio
 - Localização: `src/presentation/`
 
-#### Componentes:
+#### Componentes
+
 - Interface web responsiva
 - Configurações de processamento
 - Visualização de resultados
@@ -57,11 +65,13 @@ O sistema de detecção de riscos em vídeo é construído seguindo os princípi
 ## Otimizações
 
 ### GPU
+
 - Detecção automática de hardware
 - Configurações específicas para T4 e Zero-GPU
 - Gerenciamento de memória otimizado
 
 ### CPU
+
 - Fallback automático
 - Otimizações para processamento em CPU
 - Cache de resultados
@@ -81,14 +91,17 @@ graph TD
 
 ## Considerações de Design
 
-1. **Inversão de Dependência**
-   - Interfaces abstratas no domínio
-   - Implementações concretas na infraestrutura
+### 1. Inversão de Dependência
+
+- Interfaces abstratas no domínio
+- Implementações concretas na infraestrutura
+
+### 2. Single Responsibility
+
+- Cada componente com responsabilidade única
+- Separação clara de concerns
 
-2. **Single Responsibility**
-   - Cada componente com responsabilidade única
-   - Separação clara de concerns
+### 3. Open/Closed
 
-3. **Open/Closed**
-   - Extensível para novos detectores
-   - Fácil adição de novos serviços 
+- Extensível para novos detectores
+- Fácil adição de novos serviços 

docs/development/development.md

@@ -0,0 +1,202 @@
+# Guia de Desenvolvimento
+
+## Ambiente de Desenvolvimento
+
+### Configuração do Ambiente
+
+1. **Preparação do Sistema**
+
+    - Instale Python 3.10+
+    - Configure CUDA 11.8+ (para GPU)
+    - Instale Git
+
+2. **Configuração do Projeto**
+
+    ```bash
+    # Clone o repositório
+    git clone https://github.com/seu-usuario/hackatoon-1iadt.git
+    cd hackatoon-1iadt
+
+    # Crie e ative o ambiente virtual
+    python -m venv venv
+    source venv/bin/activate  # Linux/Mac
+    .\venv\Scripts\activate   # Windows
+
+    # Instale as dependências
+    pip install -r requirements.txt
+    ```
+
+### Ferramentas Recomendadas
+
+- **IDE**: VSCode com extensões:
+  - Python
+  - Pylance
+  - GitLens
+  - Python Test Explorer
+
+- **Linters e Formatadores**:
+  - Ruff
+  - Black
+  - isort
+  - mypy
+
+## Padrões de Código
+
+### Estilo de Código
+
+1. **PEP 8**
+
+    - Máximo 88 caracteres por linha
+    - 4 espaços para indentação
+    - Sem tabs, apenas espaços
+
+2. **Docstrings**
+
+    ```python
+    def process_video(video_path: str, fps: int = 2) -> dict:
+        """Processa um vídeo para detecção de objetos.
+
+        Args:
+            video_path: Caminho do arquivo de vídeo
+            fps: Frames por segundo para processamento
+
+        Returns:
+            Dicionário com resultados da detecção
+
+        Raises:
+            FileNotFoundError: Se o vídeo não for encontrado
+        """
+        pass
+    ```
+
+3. **Type Hints**
+
+    ```python
+    from typing import List, Dict, Optional
+
+    def detect_objects(
+        frame: np.ndarray,
+        confidence: float = 0.5
+    ) -> List[Dict[str, Any]]:
+        pass
+    ```
+
+## Testes
+
+### Estrutura de Testes
+
+```plaintext
+tests/
+├── unit/
+│   ├── test_detector.py
+│   └── test_video_processor.py
+├── integration/
+│   └── test_api.py
+└── conftest.py
+```
+
+### Exemplos de Testes
+
+```python
+def test_detector_initialization():
+    """Testa a inicialização do detector."""
+    detector = WeaponDetector()
+    assert detector.is_initialized()
+    assert detector.device == "cuda" if torch.cuda.is_available() else "cpu"
+
+@pytest.mark.parametrize("threshold", [0.3, 0.5, 0.7])
+def test_detection_threshold(threshold):
+    """Testa diferentes limiares de detecção."""
+    detector = WeaponDetector()
+    result = detector.detect(sample_image, threshold=threshold)
+    assert all(d["confidence"] >= threshold for d in result)
+```
+
+## Fluxo de Trabalho
+
+### Git Flow
+
+1. **Branches Principais**
+
+    - `main`: Produção
+    - `develop`: Desenvolvimento
+    - `feature/*`: Novas funcionalidades
+    - `fix/*`: Correções
+    - `release/*`: Preparação de release
+
+2. **Commits**
+
+    ```plaintext
+    feat: Adiciona detecção em tempo real
+    ^--^  ^------------------------^
+    |     |
+    |     +-> Descrição no presente
+    |
+    +-------> Tipo: feat, fix, docs, style, refactor
+    ```
+
+### CI/CD
+
+1. **GitHub Actions**
+
+    ```yaml
+    name: CI
+    on: [push, pull_request]
+    jobs:
+      test:
+        runs-on: ubuntu-latest
+        steps:
+          - uses: actions/checkout@v2
+          - name: Test
+            run: pytest
+    ```
+
+2. **Deploy**
+
+    ```bash
+    # Deploy para staging
+    ./deploy.sh staging
+
+    # Deploy para produção
+    ./deploy.sh production
+    ```
+
+## Debugging
+
+### Logs
+
+```python
+import logging
+
+logger = logging.getLogger(__name__)
+logger.info("Processando frame %d", frame_number)
+```
+
+### Profiling
+
+```python
+import cProfile
+
+def profile_detection():
+    profiler = cProfile.Profile()
+    profiler.enable()
+    # código
+    profiler.disable()
+    profiler.print_stats()
+```
+
+## Otimizações
+
+### GPU
+
+- Batch processing
+- Memória pinned
+- Async data loading
+- Cache de modelos
+
+### CPU
+
+- Multiprocessing
+- NumPy vectorization
+- Cache de resultados
+- Otimização de memória 

docs/faq.md

@@ -0,0 +1,145 @@
+# FAQ
+
+## Geral
+
+### Como o sistema funciona?
+
+O sistema utiliza um modelo de IA (OWL-ViT) para detectar objetos de risco em vídeos.
+O processamento pode ser feito em GPU ou CPU, com otimizações específicas para cada caso.
+
+### Quais objetos são detectados?
+
+#### Armas de Fogo
+
+- Pistolas
+- Rifles
+- Espingardas
+
+#### Armas Brancas
+
+- Facas
+- Canivetes
+- Objetos pontiagudos
+
+#### Outros Objetos
+
+- Bastões
+- Objetos contundentes
+- Materiais explosivos
+
+## Técnico
+
+### Requisitos de Hardware
+
+#### GPU
+
+- NVIDIA T4 16GB (recomendado)
+- CUDA 11.8+
+- 16GB RAM
+
+#### CPU
+
+- 8+ cores
+- 32GB RAM
+- SSD para cache
+
+### Problemas Comuns
+
+#### Erro CUDA
+
+**Problema**: `CUDA not available`
+
+**Solução**:
+
+```bash
+nvidia-smi
+pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cu118
+```
+
+#### Memória Insuficiente
+
+**Problema**: `CUDA out of memory`
+
+**Solução**:
+
+- Reduza o tamanho do batch
+- Diminua a resolução
+- Ajuste `GPU_MEMORY_FRACTION` no `.env`
+
+## Performance
+
+### Como melhorar a performance?
+
+#### GPU
+
+- Use batch processing
+- Ative half precision
+- Otimize o cache de modelos
+
+#### CPU
+
+- Ative multiprocessing
+- Use vetorização NumPy
+- Implemente cache de resultados
+
+### Configurações Recomendadas
+
+```plaintext
+# GPU T4
+GPU_MEMORY_FRACTION=0.9
+BATCH_SIZE=16
+USE_HALF_PRECISION=true
+
+# CPU
+MAX_WORKERS=8
+CACHE_SIZE=1000
+USE_MULTIPROCESSING=true
+```
+
+## Deployment
+
+### Como fazer deploy no Hugging Face?
+
+1. Configure as credenciais:
+
+    ```bash
+    cp .env.example .env.huggingface
+    ```
+
+2. Edite as variáveis:
+
+    ```plaintext
+    HF_SPACE_ID=seu-espaco
+    HF_TOKEN=seu_token
+    ```
+
+3. Execute o deploy:
+
+    ```bash
+    ./deploy.sh
+    ```
+
+### Monitoramento
+
+- Use os logs em `logs/app.log`
+- Monitore GPU com `nvidia-smi`
+- Verifique métricas no Hugging Face
+
+## Segurança
+
+### Como proteger as credenciais?
+
+1. Use variáveis de ambiente:
+
+    ```bash
+    cp .env.example .env
+    ```
+
+2. Nunca comite arquivos `.env`
+3. Use secrets no Hugging Face
+
+### Validação de Entrada
+
+- Limite o tamanho dos vídeos
+- Verifique formatos permitidos
+- Sanitize inputs 

src/domain/detectors/base.py

@@ -7,6 +7,7 @@ import os
 import cv2
 from PIL import Image
 import time
+import sys
 
 logger = logging.getLogger(__name__)
 

src/presentation/web/gradio_interface.py

@@ -223,33 +223,17 @@ class GradioInterface:
                         """)
             # Vídeos de exemplo
             if sample_videos:
-                with gr.Group():
-                    gr.Markdown("### Vídeos de Exemplo")
-                    with gr.Row():
-                        with gr.Column(scale=3):
-                            gr.Markdown("#### Vídeo")
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Ação")
-                    
-                    for video in sample_videos:
-                        with gr.Row():
-                            with gr.Column(scale=3):                            
-                                gr.PlayableVideo(                                    
-                                    value=video['path'],
-                                    format="mp4",
-                                    height=150,
-                                    interactive=True,
-                                    show_label=True)
-                                
-                            with gr.Column(scale=1, min_width=100):
-                                gr.Button(
-                                    "📥 Carregar",
-                                    size="md"
-                                ).click(
-                                    fn=self.load_sample_video,
-                                    inputs=[gr.State(video['path'])],
-                                    outputs=[input_video]
-                                )
+                gr.Markdown("### Vídeos de Exemplo")
+                examples = [
+                    [video['path']] for video in sample_videos
+                ]
+                gr.Examples(
+                    examples=examples,
+                    inputs=input_video,
+                    outputs=input_video,
+                    fn=self.load_sample_video,
+                    label="Clique em um vídeo para carregá-lo"
+                )
             
             # Configurar callback do botão
             submit_btn.click(