ajustes finais para T4 e doc

README.md

@@ -7,7 +7,7 @@ sdk: gradio
 sdk_version: 5.15.0
 app_file: app.py
 pinned: false
-license: mit
+license: apache-2.0
 tags:
   - security
   - computer-vision
@@ -55,7 +55,9 @@ GPU/CPU otimizado.
 - Processamento otimizado em GPU (NVIDIA T4) e CPU
 - Interface web intuitiva com Gradio
 - API REST para integração
-- Suporte a webhooks para notificações
+- Sistema de notificações:
+  - Webhook para integrações personalizadas
+  - E-mail para alertas diretos
 - Métricas detalhadas de processamento
 
 ## Requisitos
@@ -170,7 +172,7 @@ src/
 
 ## Licença
 
-Este projeto está licenciado sob a MIT License - veja o arquivo [LICENSE](LICENSE)
+Este projeto está licenciado sob a Apache License 2.0 - veja o arquivo [LICENSE](LICENSE)
 para detalhes.
 
 ## Contribuição

docs/architecture/overview.md

@@ -163,11 +163,59 @@ class NewDetector(DetectorInterface):
 ### 3. Sistema de Notificações
 
 ```python
-class NewNotificationService(NotificationService):
-    """Novo serviço de notificação."""
+class NotificationService {
+    """Serviço de notificação abstrato."""
     def send_notification(self):
         # Implementação específica
         pass
+}
+
+class EmailNotification(NotificationService):
+    """Serviço de notificação por e-mail."""
+    def send_notification(self, detection_data: dict, target: str):
+        # Envia e-mail com detalhes da detecção
+        pass
+
+class WebhookNotification(NotificationService):
+    """Serviço de notificação via webhook."""
+    def send_notification(self, detection_data: dict, webhook_url: str):
+        # Envia POST request para o webhook configurado
+        pass
+```
+
+#### Tipos de Notificação Implementados
+
+1. **E-mail**
+   - Envio de alertas por e-mail
+   - Suporte a templates HTML
+   - Detalhes das detecções incluídos
+   - Configurável via variáveis de ambiente
+
+2. **Webhook**
+   - Integração com sistemas externos
+   - Payload JSON customizável
+   - Suporte a autenticação
+   - Headers configuráveis
+   - Retry com backoff exponencial
+
+#### Fluxo de Notificações
+
+```mermaid
+sequenceDiagram
+    participant D as Detector
+    participant NS as NotificationService
+    participant E as EmailService
+    participant W as WebhookService
+    
+    D->>NS: Detecção Encontrada
+    alt Email Configurado
+        NS->>E: Envia Alerta
+        E-->>NS: Status Envio
+    else Webhook Configurado
+        NS->>W: Envia POST
+        W-->>NS: Status Request
+    end
+    NS-->>D: Resultado
 ```
 
 ## Fluxo de Processamento

src/domain/detectors/gpu.py

@@ -136,7 +136,6 @@ class WeaponDetectorGPU(BaseDetector):
         gc.collect()
 
     def process_video(self, video_path: str, fps: int = None, threshold: float = 0.3, resolution: int = 640) -> Tuple[str, Dict]:
-        """Processa um vídeo."""
         metrics = {
             "total_time": 0,
             "frame_extraction_time": 0,
@@ -165,7 +164,7 @@ class WeaponDetectorGPU(BaseDetector):
             
             # Processar frames em batch
             t0 = time.time()
-            batch_size = 16  # Aumentado para T4 dedicada
+            batch_size = 8  # Reduzido para evitar erros de memória
             detections_by_frame = []
             
             for i in range(0, len(frames), batch_size):
@@ -179,61 +178,73 @@ class WeaponDetectorGPU(BaseDetector):
                     frame_pil = self._preprocess_image(frame_pil)
                     batch_pil_frames.append(frame_pil)
                 
-                # Processar batch
-                batch_inputs = self.owlv2_processor(
-                    images=batch_pil_frames,
-                    return_tensors="pt",
-                    padding=True
-                )
-                batch_inputs = {
-                    key: val.to(self.device) 
-                    for key, val in batch_inputs.items()
-                }
-                
-                # Inferência em batch
-                with torch.no_grad():
-                    inputs = {**batch_inputs, **self.processed_text}
-                    outputs = self.owlv2_model(**inputs)
-                    
-                    target_sizes = torch.tensor(
-                        [frame.size[::-1] for frame in batch_pil_frames],
-                        device=self.device
+                try:
+                    # Processar batch
+                    batch_inputs = self.owlv2_processor(
+                        images=batch_pil_frames,
+                        return_tensors="pt",
+                        padding=True
                     )
-                    results = self.owlv2_processor.post_process_grounded_object_detection(
-                        outputs=outputs,
-                        target_sizes=target_sizes,
-                        threshold=threshold
-                    )
-                
-                # Processar resultados do batch
-                for frame_idx, frame_results in enumerate(results):
-                    if len(frame_results["scores"]) > 0:
-                        scores = frame_results["scores"]
-                        boxes = frame_results["boxes"]
-                        labels = frame_results["labels"]
+                    batch_inputs = {
+                        key: val.to(self.device) 
+                        for key, val in batch_inputs.items()
+                    }
+                    
+                    # Inferência em batch
+                    with torch.no_grad():
+                        inputs = {**batch_inputs, **self.processed_text}
+                        outputs = self.owlv2_model(**inputs)
                         
-                        frame_detections = []
-                        for score, box, label in zip(scores, boxes, labels):
-                            score_val = score.item()
-                            if score_val >= threshold:
-                                label_idx = min(label.item(), len(self.text_queries) - 1)
-                                label_text = self.text_queries[label_idx]
-                                frame_detections.append({
-                                    "confidence": round(score_val * 100, 2),
-                                    "box": [int(x) for x in box.tolist()],
-                                    "label": label_text
+                        target_sizes = torch.tensor(
+                            [frame.size[::-1] for frame in batch_pil_frames],
+                            device=self.device
+                        )
+                        results = self.owlv2_processor.post_process_grounded_object_detection(
+                            outputs=outputs,
+                            target_sizes=target_sizes,
+                            threshold=threshold
+                        )
+                    
+                    # Processar resultados do batch
+                    for frame_idx, frame_results in enumerate(results):
+                        if len(frame_results["scores"]) > 0:
+                            scores = frame_results["scores"]
+                            boxes = frame_results["boxes"]
+                            labels = frame_results["labels"]
+                            
+                            frame_detections = []
+                            for score, box, label in zip(scores, boxes, labels):
+                                score_val = score.item()
+                                if score_val >= threshold:
+                                    label_idx = min(label.item(), len(self.text_queries) - 1)
+                                    label_text = self.text_queries[label_idx]
+                                    frame_detections.append({
+                                        "confidence": round(score_val * 100, 2),
+                                        "box": [int(x) for x in box.tolist()],
+                                        "label": label_text,
+                                        "timestamp": (i + frame_idx) / (fps or 2)
+                                    })
+                            
+                            if frame_detections:
+                                frame_detections = self._apply_nms(frame_detections)
+                                detections_by_frame.append({
+                                    "frame": i + frame_idx,
+                                    "detections": frame_detections
                                 })
-                        
-                        if frame_detections:
-                            frame_detections = self._apply_nms(frame_detections)
-                            detections_by_frame.append({
-                                "frame": i + frame_idx,
-                                "detections": frame_detections
-                            })
                 
-                # Liberar memória do batch
-                del batch_inputs, outputs
-                torch.cuda.empty_cache()
+                except RuntimeError as e:
+                    logger.error(f"Erro no processamento do batch: {str(e)}")
+                    if "out of memory" in str(e):
+                        torch.cuda.empty_cache()
+                        gc.collect()
+                    continue
+                    
+                finally:
+                    # Liberar memória do batch
+                    del batch_inputs
+                    if 'outputs' in locals():
+                        del outputs
+                    torch.cuda.empty_cache()
             
             # Atualizar métricas finais
             metrics["analysis_time"] = time.time() - t0

src/presentation/web/gradio_interface.py

@@ -190,7 +190,7 @@ class GradioInterface:
                     )
                 
                     submit_btn = gr.Button(
-                        "Analisar Vídeo",
+                        "Detectar",
                         variant="primary",
                         scale=2
                     )
@@ -280,24 +280,24 @@ class GradioInterface:
         response = self.use_case.execute(request)
         
         # Formatar saída para o Gradio
-        status_color = "#ff0000" if response.detections else "#00ff00"
+        status_color = "#ff0000" if response.detection_result.detections else "#00ff00"
         status_html = f"""
         <div style='padding: 1em; background: {status_color}20; border-radius: 8px;'>
             <h3 style='color: {status_color}; margin: 0;'>
-                {"⚠️ RISCO DETECTADO" if response.detections else "✅ SEGURO"}
+                {"⚠️ RISCO DETECTADO" if response.detection_result.detections else "✅ SEGURO"}
             </h3>
             <p style='margin: 0.5em 0;'>
-                Processado em: {response.device_type}<br>
-                Total de detecções: {len(response.detections)}<br>
-                Frames analisados: {response.frames_analyzed}<br>
-                Tempo total: {response.total_time:.2f}s
+                Processado em: {response.detection_result.device_type}<br>
+                Total de detecções: {len(response.detection_result.detections)}<br>
+                Frames analisados: {response.detection_result.frames_analyzed}<br>
+                Tempo total: {response.detection_result.total_time:.2f}s
             </p>
         </div>
         """
         
-        if response.detections:
+        if response.detection_result.detections:
             status_html += "<div style='margin-top: 1em;'><h4>Detecções:</h4><ul>"
-            for det in response.detections[:5]:  # Mostrar até 5 detecções
+            for det in response.detection_result.detections[:5]:  # Mostrar até 5 detecções
                 confidence_pct = det.confidence * 100 if det.confidence <= 1.0 else det.confidence
                 status_html += f"""
                 <li style='margin: 0.5em 0;'>
@@ -305,8 +305,8 @@ class GradioInterface:
                     Confiança: {confidence_pct:.1f}%<br>
                     Frame: {det.frame}
                 </li>"""
-            if len(response.detections) > 5:
-                status_html += f"<li>... e mais {len(response.detections) - 5} detecção(ões)</li>"
+            if len(response.detection_result.detections) > 5:
+                status_html += f"<li>... e mais {len(response.detection_result.detections) - 5} detecção(ões)</li>"
             status_html += "</ul></div>"
         
         return (