Update app.py

app.py

@@ -1,5 +1,6 @@
 import os
 import json
+import time
 from datetime import datetime
 from utils.video_processor import VideoProcessor
 from utils.mediapipe_utils import MediaPipeProcessor
@@ -11,45 +12,58 @@ class LibrasProcessingPipeline:
         self.setup_directories()
         
     def setup_directories(self):
-        """Cria os diretórios necessários"""
-        os.makedirs(self.config['input_dir'], exist_ok=True)
-        os.makedirs(self.config['normalized_dir'], exist_ok=True)
-        os.makedirs(self.config['keypoints_dir'], exist_ok=True)
-        os.makedirs(self.config['huggingface_dir'], exist_ok=True)
+        """Cria os diretórios necessários automaticamente"""
+        directories = [
+            self.config['input_dir'],
+            self.config['normalized_dir'],
+            self.config['keypoints_dir'],
+            self.config['huggingface_dir']
+        ]
+        
+        for directory in directories:
+            os.makedirs(directory, exist_ok=True)
+            print(f"Diretório criado/verificado: {directory}")
     
     def run_pipeline(self, video_filename):
         """Executa o pipeline completo"""
         print(f"Iniciando processamento do vídeo: {video_filename}")
         
-        # 1. Normalização do vídeo
-        print("1. Normalizando vídeo...")
-        normalized_path = self.normalize_video(video_filename)
-        
-        # 2. Extração de keypoints com MediaPipe
-        print("2. Extraindo keypoints...")
-        keypoints_data = self.extract_keypoints(normalized_path)
-        
-        # 3. Salvar JSON com keypoints
-        print("3. Salvando keypoints...")
-        json_path = self.save_keypoints(keypoints_data, video_filename)
-        
-        # 4. Preparar para Hugging Face
-        print("4. Preparando para Hugging Face...")
-        hf_ready_path = self.prepare_for_huggingface(
-            normalized_path, json_path, video_filename
-        )
-        
-        # 5. Upload para Hugging Face (opcional)
-        if self.config.get('upload_to_hf', False):
-            print("5. Upload para Hugging Face...")
-            self.upload_to_huggingface(hf_ready_path)
-        
-        print("Pipeline concluído com sucesso!")
-        return {
-            'normalized_video': normalized_path,
-            'keypoints_json': json_path,
-            'hf_ready': hf_ready_path
-        }
+        try:
+            # 1. Normalização do vídeo
+            print("1. Normalizando vídeo...")
+            normalized_path = self.normalize_video(video_filename)
+            
+            # 2. Extração de keypoints com MediaPipe
+            print("2. Extraindo keypoints...")
+            keypoints_data = self.extract_keypoints(normalized_path)
+            
+            # 3. Salvar JSON com keypoints
+            print("3. Salvando keypoints...")
+            json_path = self.save_keypoints(keypoints_data, video_filename)
+            
+            # 4. Preparar para Hugging Face
+            print("4. Preparando para Hugging Face...")
+            hf_ready_path = self.prepare_for_huggingface(
+                normalized_path, json_path, video_filename
+            )
+            
+            # 5. Upload para Hugging Face (opcional)
+            if self.config.get('upload_to_hf', False):
+                print("5. Upload para Hugging Face...")
+                self.upload_to_huggingface(hf_ready_path)
+            
+            print("Pipeline concluído com sucesso!")
+            return {
+                'normalized_video': normalized_path,
+                'keypoints_json': json_path,
+                'hf_ready': hf_ready_path
+            }
+            
+        except Exception as e:
+            print(f"Erro no pipeline: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
     
     def normalize_video(self, video_filename):
         """Normaliza o vídeo usando OpenCV/FFmpeg"""
@@ -90,6 +104,7 @@ class LibrasProcessingPipeline:
         with open(output_path, 'w', encoding='utf-8') as f:
             json.dump(serializable_data, f, indent=2, ensure_ascii=False)
         
+        print(f"Keypoints salvos em: {output_path}")
         return output_path
     
     def prepare_for_huggingface(self, video_path, json_path, original_filename):
@@ -103,26 +118,29 @@ class LibrasProcessingPipeline:
         if os.path.exists(video_path):
             import shutil
             shutil.copy2(video_path, video_dest)
+            print(f"Vídeo copiado para: {video_dest}")
         
         # Copiar JSON de keypoints
         json_dest = os.path.join(hf_dir, f"{base_name}_keypoints.json")
         if os.path.exists(json_path):
             import shutil
             shutil.copy2(json_path, json_dest)
+            print(f"JSON copiado para: {json_dest}")
         
         # Criar metadata
         metadata = {
             'processing_date': datetime.now().isoformat(),
             'original_video': original_filename,
             'keypoints_format': 'MediaPipe Holistic',
-            'frame_count': len(self.load_json(json_path)),
-            'video_resolution': self.get_video_info(video_path)
+            'frame_count': len(self.load_json(json_path)) if os.path.exists(json_path) else 0,
+            'video_resolution': self.get_video_info(video_path) if os.path.exists(video_path) else {}
         }
         
         metadata_path = os.path.join(hf_dir, 'metadata.json')
         with open(metadata_path, 'w', encoding='utf-8') as f:
             json.dump(metadata, f, indent=2, ensure_ascii=False)
         
+        print(f"Metadata criado em: {metadata_path}")
         return hf_dir
     
     def upload_to_huggingface(self, directory_path):
@@ -132,6 +150,8 @@ class LibrasProcessingPipeline:
     
     def load_json(self, json_path):
         """Carrega arquivo JSON"""
+        if not os.path.exists(json_path):
+            return []
         with open(json_path, 'r', encoding='utf-8') as f:
             return json.load(f)
     
@@ -169,19 +189,35 @@ config = {
     
     'huggingface': {
         'repo_id': 'your-username/your-repo-name',
-        'token': 'your-hf-token',  # Opcional: só se quiser upload automático
-        'upload_to_hf': False  # Mudar para True para habilitar upload
+        'token': 'your-hf-token',
+        'upload_to_hf': False
     }
 }
 
 if __name__ == "__main__":
-    # Exemplo de uso
+    # Criar diretórios automaticamente
     pipeline = LibrasProcessingPipeline(config)
     
-    # Processar um vídeo específico
-    try:
-        result = pipeline.run_pipeline("video_libras.mp4")
-        print(f"Resultados salvos em: {result}")
+    # Verificar se existe vídeo na pasta input
+    input_dir = config['input_dir']
+    video_files = [f for f in os.listdir(input_dir) if f.endswith(('.mp4', '.avi', '.mov'))]
     
-    except Exception as e:
-        print(f"Erro no processamento: {e}")
+    if not video_files:
+        print(f"Nenhum vídeo encontrado na pasta '{input_dir}'")
+        print("Por favor, coloque um vídeo na pasta input/")
+    else:
+        # Processar o primeiro vídeo encontrado
+        video_filename = video_files[0]
+        print(f"Processando: {video_filename}")
+        
+        start_time = time.time()
+        result = pipeline.run_pipeline(video_filename)
+        end_time = time.time()
+        
+        if result:
+            print(f"\n✅ Processamento concluído em {end_time - start_time:.2f} segundos")
+            print(f"📁 Resultados:")
+            for key, path in result.items():
+                print(f"   {key}: {path}")
+        else:
+            print("❌ Falha no processamento")