Limpeza de codigo

src/domain/detectors/gpu.py

@@ -24,7 +24,6 @@ class WeaponDetectorGPU(BaseDetector):
         self._initialize()
     
     def _initialize(self):
-        """Inicializa o modelo."""
         try:
             # Configurar device
             if not torch.cuda.is_available():
@@ -55,11 +54,7 @@ class WeaponDetectorGPU(BaseDetector):
                 text=self.text_queries,
                 return_tensors="pt",
                 padding=True
-            )
-            self.processed_text = {
-                key: val.to(self.device) 
-                for key, val in self.processed_text.items()
-            }
+            ).to(self.device)
             
             logger.info("Inicialização GPU completa!")
             self._initialized = True
@@ -78,16 +73,11 @@ class WeaponDetectorGPU(BaseDetector):
             image_inputs = self.owlv2_processor(
                 images=image,
                 return_tensors="pt"
-            )
-            image_inputs = {
-                key: val.to(self.device) 
-                for key, val in image_inputs.items()
-            }
+            ).to(self.device)
             
             # Inferência
             with torch.no_grad():
-                inputs = {**image_inputs, **self.processed_text}
-                outputs = self.owlv2_model(**inputs)
+                outputs = self.owlv2_model(**{**image_inputs, **self.processed_text})
                 
                 target_sizes = torch.tensor([image.size[::-1]], device=self.device)
                 results = self.owlv2_processor.post_process_grounded_object_detection(
@@ -99,26 +89,19 @@ class WeaponDetectorGPU(BaseDetector):
             # Processar detecções
             detections = []
             if len(results["scores"]) > 0:
-                scores = results["scores"]
-                boxes = results["boxes"]
-                labels = results["labels"]
-                
-                for score, box, label in zip(scores, boxes, labels):
+                for score, box, label in zip(results["scores"], results["boxes"], results["labels"]):
                     score_val = score.item()
                     if score_val >= threshold:
-                        # Garantir que o índice está dentro dos limites
                         label_idx = min(label.item(), len(self.text_queries) - 1)
-                        label_text = self.text_queries[label_idx]
                         detections.append({
-                            "confidence": round(score_val * 100, 2),  # Converter para porcentagem
+                            "confidence": round(score_val * 100, 2),
                             "box": [int(x) for x in box.tolist()],
-                            "label": label_text
+                            "label": self.text_queries[label_idx]
                         })
-                        logger.debug(f"Detecção: {label_text} ({score_val * 100:.2f}%)")
+                        logger.debug(f"Detecção: {self.text_queries[label_idx]} ({score_val * 100:.2f}%)")
             
             # Aplicar NMS nas detecções
-            detections = self._apply_nms(detections)
-            return detections
+            return self._apply_nms(detections)
             
         except Exception as e:
             logger.error(f"Erro em detect_objects: {str(e)}")
@@ -136,6 +119,7 @@ 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 para detecção de objetos."""
         metrics = {
             "total_time": 0,
             "frame_extraction_time": 0,
@@ -175,80 +159,7 @@ class WeaponDetectorGPU(BaseDetector):
             
             # Processar frames
             t0 = time.time()
-            detections_by_frame = []
-            
-            # Pré-alocar tensores para evitar alocações frequentes
-            with torch.cuda.device(self.device):
-                torch.cuda.empty_cache()
-                
-            for i, frame in enumerate(frames):
-                try:
-                    # Preparar frame
-                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                    frame_pil = Image.fromarray(frame_rgb)
-                    frame_pil = self._preprocess_image(frame_pil)
-                    
-                    # Processar frame
-                    inputs = self.owlv2_processor(
-                        images=frame_pil,
-                        return_tensors="pt"
-                    )
-                    inputs = {
-                        key: val.to(self.device) 
-                        for key, val in inputs.items()
-                    }
-                    
-                    # Inferência
-                    with torch.no_grad():
-                        model_inputs = {**inputs, **self.processed_text}
-                        outputs = self.owlv2_model(**model_inputs)
-                        
-                        target_sizes = torch.tensor([frame_pil.size[::-1]], device=self.device)
-                        results = self.owlv2_processor.post_process_grounded_object_detection(
-                            outputs=outputs,
-                            target_sizes=target_sizes,
-                            threshold=threshold
-                        )[0]
-                        
-                        # Processar resultados
-                        if len(results["scores"]) > 0:
-                            scores = results["scores"]
-                            boxes = results["boxes"]
-                            labels = 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,
-                                        "frame": i,
-                                        "timestamp": i / (fps or 2)
-                                    })
-                            
-                            if frame_detections:
-                                frame_detections = self._apply_nms(frame_detections)
-                                detections_by_frame.extend(frame_detections)
-                    
-                except Exception as e:
-                    logger.error(f"Erro ao processar frame {i}: {str(e)}")
-                    continue
-                    
-                finally:
-                    # Liberar memória
-                    if 'inputs' in locals():
-                        del inputs
-                    if 'outputs' in locals():
-                        del outputs
-                    torch.cuda.empty_cache()
-                    
-                # Log de progresso
-                if i % 10 == 0:
-                    logger.info(f"Processados {i}/{len(frames)} frames")
+            detections_by_frame = self._process_frames(frames, fps, threshold)
             
             # Atualizar métricas finais
             metrics["analysis_time"] = time.time() - t0
@@ -261,6 +172,68 @@ class WeaponDetectorGPU(BaseDetector):
             logger.error(f"Erro ao processar vídeo: {str(e)}")
             return video_path, metrics
 
+    def _process_frames(self, frames: List[np.ndarray], fps: int, threshold: float) -> List[Dict]:
+        """Processa frames do vídeo para detecção."""
+        detections_by_frame = []
+        
+        for i, frame in enumerate(frames):
+            try:
+                # Preparar frame
+                frame_pil = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+                frame_pil = self._preprocess_image(frame_pil)
+                
+                # Processar frame
+                inputs = self.owlv2_processor(
+                    images=frame_pil,
+                    return_tensors="pt"
+                ).to(self.device)
+                
+                # Inferência
+                with torch.no_grad():
+                    outputs = self.owlv2_model(**{**inputs, **self.processed_text})
+                    target_sizes = torch.tensor([frame_pil.size[::-1]], device=self.device)
+                    results = self.owlv2_processor.post_process_grounded_object_detection(
+                        outputs=outputs,
+                        target_sizes=target_sizes,
+                        threshold=threshold
+                    )[0]
+                    
+                    # Processar resultados
+                    if len(results["scores"]) > 0:
+                        frame_detections = []
+                        for score, box, label in zip(results["scores"], results["boxes"], results["labels"]):
+                            score_val = score.item()
+                            if score_val >= threshold:
+                                label_idx = min(label.item(), len(self.text_queries) - 1)
+                                frame_detections.append({
+                                    "confidence": round(score_val * 100, 2),
+                                    "box": [int(x) for x in box.tolist()],
+                                    "label": self.text_queries[label_idx],
+                                    "frame": i,
+                                    "timestamp": i / (fps or 2)
+                                })
+                        
+                        if frame_detections:
+                            detections_by_frame.extend(self._apply_nms(frame_detections))
+                
+            except Exception as e:
+                logger.error(f"Erro ao processar frame {i}: {str(e)}")
+                continue
+                
+            finally:
+                # Liberar memória
+                if 'inputs' in locals():
+                    del inputs
+                if 'outputs' in locals():
+                    del outputs
+                torch.cuda.empty_cache()
+                
+            # Log de progresso
+            if i % 10 == 0:
+                logger.info(f"Processados {i}/{len(frames)} frames")
+        
+        return detections_by_frame
+
     def _preprocess_image(self, image: Image.Image) -> Image.Image:
         """Pré-processa a imagem para o formato esperado pelo modelo."""
         try:

src/infrastructure/services/weapon_detector.py

@@ -15,25 +15,22 @@ class WeaponDetectorService(DetectorInterface):
     
     def __init__(self):
         try:
-            # Usar o Factory Pattern do domínio para criar o detector apropriado
-            self.detector = WeaponDetector.get_instance()  # Usar get_instance ao invés do construtor direto
+            self.detector = WeaponDetector.get_instance()
             if not self.detector:
                 raise RuntimeError("Falha ao criar o detector")
                 
             self.device_type = "GPU" if torch.cuda.is_available() else "CPU"
             logger.info(f"Detector inicializado em modo {self.device_type}")
             
-            # Manter referência à implementação específica para otimizações
-            if hasattr(self.detector, '_instance') and self.detector._instance is not None:
-                self._specific_detector = self.detector._instance
-            else:
-                self._specific_detector = self.detector
+            self._specific_detector = (
+                self.detector._instance 
+                if hasattr(self.detector, '_instance') and self.detector._instance is not None 
+                else self.detector
+            )
                 
-            # Verificar se o detector foi inicializado corretamente
             if not hasattr(self._specific_detector, 'process_video'):
                 raise RuntimeError("Detector não possui método process_video")
                 
-            # Garantir que o detector está inicializado
             if hasattr(self._specific_detector, 'initialize'):
                 self._specific_detector.initialize()
                 
@@ -53,7 +50,6 @@ class WeaponDetectorService(DetectorInterface):
             if not self._specific_detector:
                 raise RuntimeError("Detector não inicializado")
                 
-            # Garantir que o detector está inicializado
             if hasattr(self._specific_detector, 'initialize'):
                 self._specific_detector.initialize()
                 
@@ -68,7 +64,6 @@ class WeaponDetectorService(DetectorInterface):
                 logger.warning("Nenhuma métrica retornada pelo detector")
                 metrics = {}
             
-            # Converter detecções para entidades do domínio
             detections = []
             for detection in metrics.get('detections', []):
                 try:
@@ -82,7 +77,6 @@ class WeaponDetectorService(DetectorInterface):
                 except Exception as e:
                     logger.error(f"Erro ao processar detecção: {str(e)}")
             
-            # Criar resultado com informações técnicas
             result = DetectionResult(
                 video_path=output_path or video_path,
                 detections=detections,
@@ -121,7 +115,6 @@ class WeaponDetectorService(DetectorInterface):
             if hasattr(self._specific_detector, 'clean_memory'):
                 self._specific_detector.clean_memory()
                 
-            # Forçar coleta de lixo
             gc.collect()
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
@@ -180,7 +173,6 @@ class WeaponDetectorService(DetectorInterface):
             return self._get_empty_cache_stats()
             
     def _get_empty_cache_stats(self) -> dict:
-        """Retorna estatísticas vazias do cache."""
         return {
             "cache_size": 0,
             "max_size": 0,

src/presentation/web/gradio_interface.py

@@ -21,31 +21,8 @@ class GradioInterface:
         self.default_resolution = "640" if self.detector.device_type == "GPU" else "480"
         self.is_huggingface = os.getenv('SPACE_ID') is not None
         
-        # Configurar dataset apenas no ambiente Hugging Face
         if self.is_huggingface:
-            self.dataset_id = "marcuscanhaco/weapon-test"
-            self.cache_dir = os.path.join(tempfile.gettempdir(), 'weapon_detection_videos')
-            os.makedirs(self.cache_dir, exist_ok=True)
-            
-            # Configurar API do Hugging Face
-            self.hf_token = os.getenv('HF_TOKEN')
-            self.api = HfApi(token=self.hf_token)
-            
-            # Listar arquivos do dataset
-            try:
-                files = self.api.list_repo_files(self.dataset_id, repo_type="dataset")
-                self.sample_videos = [
-                    {
-                        'path': f,
-                        'name': Path(f).stem.replace('_', ' ').title(),
-                        'ground_truth': '🚨 Vídeo de Teste'
-                    }
-                    for f in files if f.lower().endswith(('.mp4', '.avi', '.mov', '.mkv'))
-                ]
-                logger.info(f"Encontrados {len(self.sample_videos)} vídeos no dataset")
-            except Exception as e:
-                logger.error(f"Erro ao listar arquivos do dataset: {str(e)}")
-                self.sample_videos = []
+            self._setup_huggingface_environment()
         
         self.use_case = ProcessVideoUseCase(
             detector=self.detector,
@@ -54,6 +31,30 @@ class GradioInterface:
             default_resolution=int(self.default_resolution)
         )
     
+    def _setup_huggingface_environment(self):
+        """Configura o ambiente Hugging Face."""
+        self.dataset_id = "marcuscanhaco/weapon-test"
+        self.cache_dir = os.path.join(tempfile.gettempdir(), 'weapon_detection_videos')
+        os.makedirs(self.cache_dir, exist_ok=True)
+        
+        self.hf_token = os.getenv('HF_TOKEN')
+        self.api = HfApi(token=self.hf_token)
+        
+        try:
+            files = self.api.list_repo_files(self.dataset_id, repo_type="dataset")
+            self.sample_videos = [
+                {
+                    'path': f,
+                    'name': Path(f).stem.replace('_', ' ').title(),
+                    'ground_truth': '🚨 Vídeo de Teste'
+                }
+                for f in files if f.lower().endswith(('.mp4', '.avi', '.mov', '.mkv'))
+            ]
+            logger.info(f"Encontrados {len(self.sample_videos)} vídeos no dataset")
+        except Exception as e:
+            logger.error(f"Erro ao listar arquivos do dataset: {str(e)}")
+            self.sample_videos = []
+    
     def _download_video(self, video_path: str) -> str:
         """Baixa um vídeo do dataset e retorna o caminho local."""
         try:
@@ -75,39 +76,47 @@ class GradioInterface:
         """Lista os vídeos de exemplo do dataset ou da pasta local."""
         try:
             if self.is_huggingface:
-                logger.info("Ambiente Hugging Face detectado")
-                videos = []
-                for video in self.sample_videos:
-                    local_path = self._download_video(video['path'])
-                    if local_path:
-                        videos.append({
-                            'path': local_path,
-                            'name': video['name'],
-                            'ground_truth': video['ground_truth']
-                        })
-                return videos
+                return self._list_huggingface_videos()
             else:
-                logger.info("Ambiente local detectado, usando pasta videos")
-                video_extensions = ['.mp4', '.avi', '.mov', '.mkv']
-                videos = []
-                base_dir = Path("videos")
-                if not base_dir.exists():
-                    os.makedirs(base_dir)
-                    logger.info(f"Diretório videos criado: {base_dir}")
-                
-                for ext in video_extensions:
-                    for video_path in base_dir.glob(f'*{ext}'):  # Removido o glob recursivo
-                        videos.append({
-                            'path': str(video_path),
-                            'name': video_path.name,
-                            'ground_truth': '📼 Vídeo de Teste'
-                        })
-                
-                return videos
+                return self._list_local_videos()
             
         except Exception as e:
             logger.error(f"Erro ao listar vídeos: {str(e)}")
             return []
+    
+    def _list_huggingface_videos(self) -> list:
+        """Lista vídeos do ambiente Hugging Face."""
+        logger.info("Ambiente Hugging Face detectado")
+        videos = []
+        for video in self.sample_videos:
+            local_path = self._download_video(video['path'])
+            if local_path:
+                videos.append({
+                    'path': local_path,
+                    'name': video['name'],
+                    'ground_truth': video['ground_truth']
+                })
+        return videos
+    
+    def _list_local_videos(self) -> list:
+        """Lista vídeos do ambiente local."""
+        logger.info("Ambiente local detectado, usando pasta videos")
+        video_extensions = ['.mp4', '.avi', '.mov', '.mkv']
+        videos = []
+        base_dir = Path("videos")
+        if not base_dir.exists():
+            os.makedirs(base_dir)
+            logger.info(f"Diretório videos criado: {base_dir}")
+        
+        for ext in video_extensions:
+            for video_path in base_dir.glob(f'*{ext}'):
+                videos.append({
+                    'path': str(video_path),
+                    'name': video_path.name,
+                    'ground_truth': '📼 Vídeo de Teste'
+                })
+        
+        return videos
 
     def load_sample_video(self, video_path: str) -> str:
         """Carrega um vídeo de exemplo."""
@@ -135,121 +144,139 @@ class GradioInterface:
             theme=gr.themes.Ocean(),
             css="footer {display: none !important}"
         ) as demo:
-            gr.Markdown(f"""# 🎯 {title} 🔪🔫
-            
-            Faça upload de um vídeo para detectar objetos perigosos.
-            Opcionalmente, configure notificações para receber alertas em caso de detecções.
+            self._create_header(title)
+            self._create_processing_config()
+            self._create_notification_config()
+            self._create_video_interface()
+            self._create_sample_videos(sample_videos)
+        
+        return demo
+    
+    def _create_header(self, title: str):
+        """Cria o cabeçalho da interface."""
+        gr.Markdown(f"""# 🎯 {title} 🔪🔫
+        
+        Faça upload de um vídeo para detectar objetos perigosos.
+        Opcionalmente, configure notificações para receber alertas em caso de detecções.
 
-            **Importante para melhor performance:**
-            - Vídeos de até 60 segundos
-            - FPS entre 1-2 para análise com maior performance
-            - FPS maior que 2 para análise com maior precisão
-            """)
-            with gr.Group():
-                gr.Markdown("""### Configuração de Processamento""")
-                with gr.Row():
-                    threshold = gr.Slider(
-                        minimum=0.1,
-                        maximum=1.0,
-                        value=0.5,
-                        step=0.1,
-                        label="Limiar de Detecção",
-                    )
-                    fps = gr.Slider(
-                        minimum=1,
-                        maximum=5,
-                        value=self.default_fps,
-                        step=1,
-                        label="Frames por Segundo",
-                    )
-                    resolution = gr.Radio(
-                        choices=["480", "640", "768"],
-                        value=self.default_resolution,
-                        label="Resolução de Processamento",
+        **Importante para melhor performance:**
+        - Vídeos de até 60 segundos
+        - FPS entre 1-2 para análise com maior performance
+        - FPS maior que 2 para análise com maior precisão
+        """)
+    
+    def _create_processing_config(self):
+        """Cria a seção de configuração de processamento."""
+        with gr.Group():
+            gr.Markdown("""### Configuração de Processamento""")
+            with gr.Row():
+                self.threshold = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.5,
+                    step=0.1,
+                    label="Limiar de Detecção",
                 )
-            with gr.Group():
-                gr.Markdown("""### Configuração de Notificações de Detecção (Opcional)""")
-                with gr.Row():
-                    notification_type = gr.Radio(
-                        choices=self.notification_factory.get_available_services(),
-                        value="email",
-                        label="Tipo de Notificação",
-                        interactive=True,
-                    )
-                    notification_target = gr.Textbox(
-                        label="Destino da Notificação (E-mail)",
-                        placeholder="[email protected]",
-                    )
+                self.fps = gr.Slider(
+                    minimum=1,
+                    maximum=5,
+                    value=self.default_fps,
+                    step=1,
+                    label="Frames por Segundo",
+                )
+                self.resolution = gr.Radio(
+                    choices=["480", "640", "768"],
+                    value=self.default_resolution,
+                    label="Resolução de Processamento",
+                )
+    
+    def _create_notification_config(self):
+        """Cria a seção de configuração de notificações."""
+        with gr.Group():
+            gr.Markdown("""### Configuração de Notificações de Detecção (Opcional)""")
             with gr.Row():
-                with gr.Column(scale=2):
-                    input_video = gr.Video(
-                        label="Vídeo de Entrada",
-                        format="mp4",
-                        interactive=True,
-                        height=400
-                    )
+                self.notification_type = gr.Radio(
+                    choices=self.notification_factory.get_available_services(),
+                    value="email",
+                    label="Tipo de Notificação",
+                    interactive=True,
+                )
+                self.notification_target = gr.Textbox(
+                    label="Destino da Notificação (E-mail)",
+                    placeholder="[email protected]",
+                )
+    
+    def _create_video_interface(self):
+        """Cria a interface de vídeo."""
+        with gr.Row():
+            with gr.Column(scale=2):
+                self.input_video = gr.Video(
+                    label="Vídeo de Entrada",
+                    format="mp4",
+                    interactive=True,
+                    height=400
+                )
                 
-                    submit_btn = gr.Button(
-                        "Detectar",
-                        variant="primary",
-                        scale=2
-                    )
-                with gr.Column(scale=1):
-                    status = gr.Textbox(
-                        label="Status da Detecção",
-                        lines=4,
-                        show_copy_button=True
-                    )
-                    with gr.Accordion("Detalhes Técnicos", open=False):
-                        json_output = gr.JSON(
-                            label="Detalhes Técnicos",
-                        )
-                    
-                    # Informações adicionais
-                    with gr.Accordion("Informações Adicionais", open=False):
-                        gr.Markdown("""
-                        ### Sobre o Detector
-                        Este sistema utiliza um modelo de IA avançado para detectar objetos perigosos em vídeos.
-                        
-                        ### Tipos de Objetos Detectados
-                        - Armas de fogo (pistolas, rifles, etc.)
-                        - Armas brancas (facas, canivetes, etc.)
-                        - Objetos perigosos (bastões, objetos pontiagudos, etc.)
-                        
-                        ### Recomendações
-                        - Use vídeos com boa iluminação
-                        - Evite vídeos muito longos
-                        - Mantenha os objetos visíveis e em foco
-                        """)
-            # Vídeos de exemplo
-            if sample_videos:
-                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"
+                self.submit_btn = gr.Button(
+                    "Detectar",
+                    variant="primary",
+                    scale=2
                 )
             
-            # Configurar callback do botão
-            submit_btn.click(
-                fn=lambda *args: self._process_video(*args),
-                inputs=[
-                    input_video,
-                    threshold,
-                    fps,
-                    resolution,
-                    notification_type,
-                    notification_target
-                ],
-                outputs=[status, json_output]
-            )
+            with gr.Column(scale=1):
+                self.status = gr.Textbox(
+                    label="Status da Detecção",
+                    lines=4,
+                    show_copy_button=True
+                )
+                with gr.Accordion("Detalhes Técnicos", open=False):
+                    self.json_output = gr.JSON(
+                        label="Detalhes Técnicos",
+                    )
+                
+                with gr.Accordion("Informações Adicionais", open=False):
+                    gr.Markdown("""
+                    ### Sobre o Detector
+                    Este sistema utiliza um modelo de IA avançado para detectar objetos perigosos em vídeos.
+                    
+                    ### Tipos de Objetos Detectados
+                    - Armas de fogo (pistolas, rifles, etc.)
+                    - Armas brancas (facas, canivetes, etc.)
+                    - Objetos perigosos (bastões, objetos pontiagudos, etc.)
+                    
+                    ### Recomendações
+                    - Use vídeos com boa iluminação
+                    - Evite vídeos muito longos
+                    - Mantenha os objetos visíveis e em foco
+                    """)
         
-        return demo
+        self.submit_btn.click(
+            fn=lambda *args: self._process_video(*args),
+            inputs=[
+                self.input_video,
+                self.threshold,
+                self.fps,
+                self.resolution,
+                self.notification_type,
+                self.notification_target
+            ],
+            outputs=[self.status, self.json_output]
+        )
+    
+    def _create_sample_videos(self, sample_videos: list):
+        """Cria a seção de vídeos de exemplo."""
+        if sample_videos:
+            gr.Markdown("### Vídeos de Exemplo")
+            examples = [
+                [video['path']] for video in sample_videos
+            ]
+            gr.Examples(
+                examples=examples,
+                inputs=self.input_video,
+                outputs=self.input_video,
+                fn=self.load_sample_video,
+                label="Clique em um vídeo para carregá-lo"
+            )
     
     def _process_video(
         self,
@@ -265,7 +292,6 @@ class GradioInterface:
             if not video_path:
                 return "Erro: Nenhum vídeo fornecido", {}
                 
-            # Usar valores padrão se não especificados
             fps = fps or self.default_fps
             resolution = resolution or self.default_resolution
             
@@ -279,39 +305,8 @@ class GradioInterface:
             )
             
             response = self.use_case.execute(request)
-            
-            # Formatar mensagem de status
             status_msg = self._format_status_message(response.detection_result)
-            
-            # Preparar JSON técnico
-            technical_data = {
-                "device_info": {
-                    "type": response.detection_result.device_type,
-                    "memory": response.memory_info,
-                    "details": response.device_info
-                },
-                "processing_stats": {
-                    "total_detections": len(response.detection_result.detections),
-                    "frames_analyzed": response.detection_result.frames_analyzed,
-                    "total_time": round(response.detection_result.total_time, 2),
-                    "frame_extraction_time": round(response.detection_result.frame_extraction_time, 2),
-                    "analysis_time": round(response.detection_result.analysis_time, 2),
-                    "fps": fps,
-                    "resolution": resolution
-                },
-                "detections": [],
-                "cache_stats": response.cache_stats if hasattr(response, 'cache_stats') else {}
-            }
-            
-            # Adicionar detecções ao JSON com informações temporais
-            for det in response.detection_result.detections[:10]:
-                technical_data["detections"].append({
-                    "label": det.label,
-                    "confidence": round(det.confidence * 100 if det.confidence <= 1.0 else det.confidence, 2),
-                    "frame": det.frame,
-                    "timestamp": f"{int(det.timestamp // 60):02d}:{int(det.timestamp % 60):02d}",
-                    "box": det.box if hasattr(det, "box") else None
-                })
+            technical_data = self._format_technical_data(response, fps, resolution)
             
             return status_msg, technical_data
             
@@ -323,6 +318,43 @@ class GradioInterface:
                 "total_detections": 0,
                 "frames_analyzed": 0
             }
+    
+    def _format_technical_data(
+        self,
+        response: Any,
+        fps: int,
+        resolution: str
+    ) -> Dict[str, Any]:
+        """Formata os dados técnicos do processamento."""
+        technical_data = {
+            "device_info": {
+                "type": response.detection_result.device_type,
+                "memory": response.memory_info,
+                "details": response.device_info
+            },
+            "processing_stats": {
+                "total_detections": len(response.detection_result.detections),
+                "frames_analyzed": response.detection_result.frames_analyzed,
+                "total_time": round(response.detection_result.total_time, 2),
+                "frame_extraction_time": round(response.detection_result.frame_extraction_time, 2),
+                "analysis_time": round(response.detection_result.analysis_time, 2),
+                "fps": fps,
+                "resolution": resolution
+            },
+            "detections": [],
+            "cache_stats": response.cache_stats if hasattr(response, 'cache_stats') else {}
+        }
+        
+        for det in response.detection_result.detections[:10]:
+            technical_data["detections"].append({
+                "label": det.label,
+                "confidence": round(det.confidence * 100 if det.confidence <= 1.0 else det.confidence, 2),
+                "frame": det.frame,
+                "timestamp": f"{int(det.timestamp // 60):02d}:{int(det.timestamp % 60):02d}",
+                "box": det.box if hasattr(det, "box") else None
+            })
+        
+        return technical_data
             
     def _format_status_message(self, result) -> str:
         """Formata a mensagem de status do processamento."""