Upload 2 files

main.py.py

@@ -0,0 +1,187 @@
+import os
+import json
+from datetime import datetime
+from utils.video_processor import VideoProcessor
+from utils.mediapipe_utils import MediaPipeProcessor
+from utils.huggingface_utils import HuggingFaceUploader
+
+class LibrasProcessingPipeline:
+    def __init__(self, config):
+        self.config = config
+        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)
+    
+    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
+        }
+    
+    def normalize_video(self, video_filename):
+        """Normaliza o vídeo usando OpenCV/FFmpeg"""
+        processor = VideoProcessor(self.config)
+        input_path = os.path.join(self.config['input_dir'], video_filename)
+        
+        # Verifica se o arquivo existe
+        if not os.path.exists(input_path):
+            raise FileNotFoundError(f"Vídeo não encontrado: {input_path}")
+        
+        output_filename = f"normalized_{video_filename}"
+        output_path = os.path.join(self.config['normalized_dir'], output_filename)
+        
+        return processor.normalize_video(input_path, output_path)
+    
+    def extract_keypoints(self, video_path):
+        """Extrai keypoints usando MediaPipe"""
+        processor = MediaPipeProcessor(self.config)
+        return processor.process_video(video_path)
+    
+    def save_keypoints(self, keypoints_data, original_filename):
+        """Salva os keypoints em formato JSON"""
+        base_name = os.path.splitext(original_filename)[0]
+        output_filename = f"{base_name}_keypoints.json"
+        output_path = os.path.join(self.config['keypoints_dir'], output_filename)
+        
+        # Converter numpy arrays para listas para serialização JSON
+        serializable_data = []
+        for frame_data in keypoints_data:
+            serializable_frame = {}
+            for key, value in frame_data.items():
+                if hasattr(value, 'tolist'):
+                    serializable_frame[key] = value.tolist()
+                else:
+                    serializable_frame[key] = value
+            serializable_data.append(serializable_frame)
+        
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(serializable_data, f, indent=2, ensure_ascii=False)
+        
+        return output_path
+    
+    def prepare_for_huggingface(self, video_path, json_path, original_filename):
+        """Prepara os arquivos para upload no Hugging Face"""
+        base_name = os.path.splitext(original_filename)[0]
+        hf_dir = os.path.join(self.config['huggingface_dir'], base_name)
+        os.makedirs(hf_dir, exist_ok=True)
+        
+        # Copiar vídeo normalizado
+        video_dest = os.path.join(hf_dir, f"{base_name}.mp4")
+        if os.path.exists(video_path):
+            import shutil
+            shutil.copy2(video_path, 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)
+        
+        # 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)
+        }
+        
+        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)
+        
+        return hf_dir
+    
+    def upload_to_huggingface(self, directory_path):
+        """Faz upload para o Hugging Face Space"""
+        uploader = HuggingFaceUploader(self.config)
+        return uploader.upload_directory(directory_path)
+    
+    def load_json(self, json_path):
+        """Carrega arquivo JSON"""
+        with open(json_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    
+    def get_video_info(self, video_path):
+        """Obtém informações do vídeo"""
+        import cv2
+        cap = cv2.VideoCapture(video_path)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        cap.release()
+        return {'width': width, 'height': height, 'fps': fps}
+
+# Configuração
+config = {
+    'input_dir': 'input',
+    'normalized_dir': 'output/normalized',
+    'keypoints_dir': 'output/keypoints',
+    'huggingface_dir': 'output/huggingface',
+    
+    'video_normalization': {
+        'target_resolution': (640, 480),
+        'target_fps': 30,
+        'normalize_brightness': True,
+        'enhance_contrast': True
+    },
+    
+    'mediapipe_config': {
+        'static_image_mode': False,
+        'model_complexity': 1,
+        'smooth_landmarks': True,
+        'min_detection_confidence': 0.5,
+        'min_tracking_confidence': 0.5
+    },
+    
+    '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
+    }
+}
+
+if __name__ == "__main__":
+    # Exemplo de uso
+    pipeline = LibrasProcessingPipeline(config)
+    
+    # Processar um vídeo específico
+    try:
+        result = pipeline.run_pipeline("video_libras.mp4")
+        print(f"Resultados salvos em: {result}")
+    
+    except Exception as e:
+        print(f"Erro no processamento: {e}")

requirements.txt

@@ -0,0 +1,7 @@
+opencv-python==4.8.0.76
+mediapipe==0.10.0
+ffmpeg-python==0.2.0
+numpy==1.24.3
+tqdm==4.65.0
+huggingface_hub==0.16.4
+requests==2.28.2