Create app.py

app.py

@@ -0,0 +1,245 @@
+import gradio as gr
+import cv2
+import numpy as np
+from pathlib import Path
+import tempfile
+import shutil
+import threading
+import time
+from datetime import datetime, timedelta
+import os
+
+class WatermarkRemover:
+    def __init__(self):
+        self.temp_dir = Path(tempfile.gettempdir()) / "watermark_removal"
+        self.temp_dir.mkdir(exist_ok=True)
+        self.start_cleanup_thread()
+    
+    def start_cleanup_thread(self):
+        """Inicia thread para limpiar archivos antiguos cada hora"""
+        def cleanup_worker():
+            while True:
+                self.cleanup_old_files()
+                time.sleep(3600)  # Revisar cada hora
+        
+        thread = threading.Thread(target=cleanup_worker, daemon=True)
+        thread.start()
+    
+    def cleanup_old_files(self):
+        """Elimina archivos temporales mayores a 2 horas"""
+        try:
+            cutoff_time = datetime.now() - timedelta(hours=2)
+            for file_path in self.temp_dir.glob("*"):
+                if file_path.is_file():
+                    file_time = datetime.fromtimestamp(file_path.stat().st_mtime)
+                    if file_time < cutoff_time:
+                        file_path.unlink()
+                        print(f"Archivo eliminado: {file_path.name}")
+        except Exception as e:
+            print(f"Error en limpieza: {e}")
+    
+    def detect_watermark_region(self, frame):
+        """
+        Detecta regiones candidatas de marca de agua usando análisis de opacidad
+        y detección de bordes
+        """
+        # Convertir a escala de grises
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        
+        # Detectar bordes para encontrar contornos de marca de agua
+        edges = cv2.Canny(gray, 50, 150)
+        
+        # Encontrar regiones con alta densidad de bordes (posibles watermarks)
+        kernel = np.ones((15, 15), np.uint8)
+        dilated = cv2.dilate(edges, kernel, iterations=2)
+        
+        # Encontrar contornos
+        contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Filtrar contornos por tamaño (marcas de agua suelen ser pequeñas/medianas)
+        watermark_regions = []
+        h, w = frame.shape[:2]
+        
+        for contour in contours:
+            area = cv2.contourArea(contour)
+            # Marca de agua típicamente entre 0.1% y 10% del área total
+            if 0.001 * (h * w) < area < 0.1 * (h * w):
+                x, y, w_box, h_box = cv2.boundingRect(contour)
+                watermark_regions.append((x, y, w_box, h_box))
+        
+        return watermark_regions
+    
+    def inpaint_watermark(self, frame, regions):
+        """
+        Elimina marcas de agua usando inpainting
+        """
+        # Crear máscara para las regiones detectadas
+        mask = np.zeros(frame.shape[:2], dtype=np.uint8)
+        
+        for (x, y, w, h) in regions:
+            # Expandir ligeramente la región para asegurar eliminación completa
+            padding = 5
+            x1 = max(0, x - padding)
+            y1 = max(0, y - padding)
+            x2 = min(frame.shape[1], x + w + padding)
+            y2 = min(frame.shape[0], y + h + padding)
+            
+            mask[y1:y2, x1:x2] = 255
+        
+        # Aplicar inpainting si hay regiones detectadas
+        if np.any(mask):
+            result = cv2.inpaint(frame, mask, 3, cv2.INPAINT_TELEA)
+            return result, True
+        
+        return frame, False
+    
+    def remove_static_patterns(self, frame, reference_frames):
+        """
+        Elimina patrones estáticos comparando con frames de referencia
+        """
+        if len(reference_frames) < 3:
+            return frame
+        
+        # Calcular mediana de frames de referencia
+        median_frame = np.median(reference_frames, axis=0).astype(np.uint8)
+        
+        # Diferencia entre frame actual y mediana
+        diff = cv2.absdiff(frame, median_frame)
+        gray_diff = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
+        
+        # Umbralizar para encontrar píxeles estáticos diferentes
+        _, mask = cv2.threshold(gray_diff, 30, 255, cv2.THRESH_BINARY_INV)
+        
+        # Dilatar máscara para incluir bordes
+        kernel = np.ones((5, 5), np.uint8)
+        mask = cv2.dilate(mask, kernel, iterations=1)
+        
+        # Aplicar inpainting en áreas estáticas diferentes
+        result = cv2.inpaint(frame, mask, 3, cv2.INPAINT_TELEA)
+        
+        return result
+    
+    def process_video(self, video_path, progress=gr.Progress()):
+        """
+        Procesa el video completo para eliminar marcas de agua móviles
+        """
+        try:
+            progress(0, desc="Iniciando procesamiento...")
+            
+            # Abrir video
+            cap = cv2.VideoCapture(video_path)
+            
+            if not cap.isOpened():
+                return None, "Error: No se pudo abrir el video"
+            
+            # Obtener propiedades del video
+            fps = int(cap.get(cv2.CAP_PROP_FPS))
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            
+            # Crear archivo de salida
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_path = self.temp_dir / f"cleaned_{timestamp}.mp4"
+            
+            # Configurar writer
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            out = cv2.VideoWriter(str(output_path), fourcc, fps, (width, height))
+            
+            reference_frames = []
+            frame_count = 0
+            
+            progress(0.1, desc="Procesando frames...")
+            
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                # Mantener buffer de frames de referencia (últimos 10 frames)
+                if len(reference_frames) >= 10:
+                    reference_frames.pop(0)
+                reference_frames.append(frame.copy())
+                
+                # Detectar y eliminar marcas de agua
+                processed_frame = frame.copy()
+                
+                # Método 1: Detección por contornos
+                regions = self.detect_watermark_region(processed_frame)
+                if regions:
+                    processed_frame, _ = self.inpaint_watermark(processed_frame, regions)
+                
+                # Método 2: Eliminación de patrones estáticos
+                if len(reference_frames) >= 5:
+                    processed_frame = self.remove_static_patterns(processed_frame, reference_frames)
+                
+                # Escribir frame procesado
+                out.write(processed_frame)
+                
+                frame_count += 1
+                if frame_count % 10 == 0:
+                    progress_value = 0.1 + (0.8 * frame_count / total_frames)
+                    progress(progress_value, desc=f"Procesando: {frame_count}/{total_frames} frames")
+            
+            # Liberar recursos
+            cap.release()
+            out.release()
+            
+            progress(1.0, desc="¡Completado!")
+            
+            return str(output_path), f"Video procesado exitosamente: {frame_count} frames"
+        
+        except Exception as e:
+            return None, f"Error durante el procesamiento: {str(e)}"
+
+# Crear instancia del removedor
+remover = WatermarkRemover()
+
+def process_video_interface(video_file):
+    """Interfaz para Gradio"""
+    if video_file is None:
+        return None, "Por favor, carga un video"
+    
+    output_path, message = remover.process_video(video_file)
+    
+    return output_path, message
+
+# Crear interfaz de Gradio
+with gr.Blocks(title="Eliminador de Marcas de Agua") as demo:
+    gr.Markdown("""
+    # 🎬 Eliminador de Marcas de Agua de Videos
+    
+    Sube tu video y esta herramienta eliminará automáticamente las marcas de agua móviles.
+    
+    **Características:**
+    - Detecta y elimina marcas de agua móviles
+    - Procesa videos de cualquier tamaño
+    - Limpieza automática de archivos temporales (cada 2 horas)
+    - Soporta múltiples formatos de video
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            video_input = gr.Video(label="Video Original")
+            process_btn = gr.Button("🚀 Eliminar Marcas de Agua", variant="primary")
+        
+        with gr.Column():
+            video_output = gr.Video(label="Video Limpio")
+            status_output = gr.Textbox(label="Estado", lines=3)
+    
+    process_btn.click(
+        fn=process_video_interface,
+        inputs=[video_input],
+        outputs=[video_output, status_output]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### 📝 Notas:
+    - Los archivos temporales se eliminan automáticamente después de 2 horas
+    - El procesamiento puede tardar según el tamaño del video
+    - Para mejores resultados, usa videos con buena calidad
+    """)
+
+if __name__ == "__main__":
+    demo.launch()