Update app.py

app.py

@@ -1,357 +1,86 @@
-import os
-import sys
-import torch
-import subprocess
-import importlib
-
-# ================== ARREGLO CRÍTICO ==================
-# Parche para torchvision.transforms.functional_tensor
-try:
-    import torchvision.transforms.functional as F
-    # Crear un alias para compatibilidad
-    sys.modules['torchvision.transforms.functional_tensor'] = F
-    # También necesitamos el rgb_to_grayscale
-    if not hasattr(F, 'rgb_to_grayscale'):
-        from torchvision.transforms.functional import rgb_to_grayscale
-        F.rgb_to_grayscale = rgb_to_grayscale
-except Exception as e:
-    print(f"Warning: Could not patch torchvision: {e}")
-
-# ================== ARREGLO ALTERNATIVO ==================
-# O también puedes forzar la importación correcta
-def patch_torchvision():
-    try:
-        # Esto evita el error directamente
-        import torchvision.transforms.functional as TF
-        import types
-        
-        # Crear módulo falso
-        fake_module = types.ModuleType('torchvision.transforms.functional_tensor')
-        fake_module.rgb_to_grayscale = TF.rgb_to_grayscale
-        sys.modules['torchvision.transforms.functional_tensor'] = fake_module
-    except:
-        pass
-
-# Ejecutar el parche ANTES de importar basicsr
-patch_torchvision()
-
-# ================== IMPORTS DESPUÉS DEL PARCHE ==================
 import gradio as gr
 import cv2
 import numpy as np
 from PIL import Image
+import torch
+from torchvision import transforms
+import warnings
+warnings.filterwarnings('ignore')
 
-# Instalar basicsr específico
-def install_deps():
-    """Instala dependencias con versiones compatibles"""
-    required_packages = [
-        'opencv-python',
-        'gradio>=4.0.0',
-        'Pillow',
-        'numpy',
-        'scipy',
-        'tqdm',
-        'lmdb',
-        'yapf',
-        'tb-nightly',
-        'flake8',
-        'yapf',
-        'isort',
-        'gdown'
-    ]
-    
-    # Intentar instalar basicsr desde GitHub (versión compatible)
-    try:
-        subprocess.check_call([sys.executable, "-m", "pip", "install", 
-                              "git+https://github.com/xinntao/BasicSR.git"])
-    except:
-        # Fallback a pip
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "basicsr"])
-
-# Llamar a la instalación (comentada en producción)
-# install_deps()
-
-# Ahora importamos realesrgan
-try:
-    from basicsr.archs.rrdbnet_arch import RRDBNet
-    from realesrgan import RealESRGANer
-except ImportError as e:
-    print(f"Error importing: {e}")
-    print("Trying alternative import...")
-    # Intento alternativo
-    try:
-        from realesrgan.realesrgan import RealESRGANer
-        from realesrgan.archs.rrdbnet_arch import RRDBNet
-    except:
-        raise ImportError("Cannot import RealESRGAN. Make sure basicsr is installed.")
-
-# ================== CONFIGURACIÓN DEL MODELO ==================
-MODEL_CONFIGS = {
-    'x4': {
-        'name': 'RealESRGAN_x4plus',
-        'url': 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth',
-        'scale': 4,
-        'blocks': 23
-    },
-    'x2': {
-        'name': 'RealESRGAN_x2plus',
-        'url': 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth',
-        'scale': 2,
-        'blocks': 23
-    },
-    'anime': {
-        'name': 'RealESRGAN_x4plus_anime',
-        'url': 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth',
-        'scale': 4,
-        'blocks': 6  # 6 blocks para anime
-    }
-}
-
-def download_model(model_key='x4'):
-    """Descarga el modelo si no existe"""
-    config = MODEL_CONFIGS[model_key]
-    model_dir = 'models'
-    os.makedirs(model_dir, exist_ok=True)
-    
-    model_filename = f"{config['name']}.pth"
-    model_path = os.path.join(model_dir, model_filename)
-    
-    if not os.path.exists(model_path):
-        print(f"📥 Descargando modelo {config['name']}...")
-        try:
-            subprocess.run(['wget', config['url'], '-O', model_path, '-q'], 
-                          check=True, capture_output=True)
-            print(f"✅ Modelo descargado: {model_filename}")
-        except:
-            # Fallback con gdown si wget falla
-            print("Intentando descarga alternativa...")
-            try:
-                import gdown
-                # Extraer ID de Google Drive si es necesario
-                gdown.download(config['url'], model_path, quiet=False)
-            except:
-                print("❌ Error al descargar el modelo")
-                return None
-    
-    return model_path, config
-
-# ================== FUNCIÓN PRINCIPAL ==================
-def upscale_image(image, model_choice='x4', scale_factor=4):
+# Función simple de upscaling usando OpenCV
+def simple_upscale(image, scale_factor=4, method='cubic'):
     """
-    Mejora la resolución de una imagen
+    Upscaling simple usando interpolación
     """
     if image is None:
         return None
     
-    try:
-        # Descargar modelo
-        model_path, config = download_model(model_choice)
-        if model_path is None:
-            return image
-        
-        # Crear modelo
-        model = RRDBNet(
-            num_in_ch=3,
-            num_out_ch=3,
-            num_feat=64,
-            num_block=config['blocks'],
-            num_grow_ch=32,
-            scale=config['scale']
+    img = np.array(image)
+    
+    # Métodos de interpolación
+    methods = {
+        'nearest': cv2.INTER_NEAREST,
+        'linear': cv2.INTER_LINEAR,
+        'cubic': cv2.INTER_CUBIC,
+        'lanczos': cv2.INTER_LANCZOS4
+    }
+    
+    # Calcular nuevo tamaño
+    height, width = img.shape[:2]
+    new_width = int(width * scale_factor)
+    new_height = int(height * scale_factor)
+    
+    # Upscale
+    if len(img.shape) == 3:  # Color
+        upscaled = cv2.resize(
+            img, 
+            (new_width, new_height), 
+            interpolation=methods.get(method, cv2.INTER_CUBIC)
         )
-        
-        # Inicializar upsampler
-        upsampler = RealESRGANer(
-            scale=config['scale'],
-            model_path=model_path,
-            model=model,
-            tile=0,  # 0 para no usar tiles
-            tile_pad=10,
-            pre_pad=0,
-            half=False  # Usar float32 para compatibilidad
+    else:  # Grayscale
+        upscaled = cv2.resize(
+            img,
+            (new_width, new_height),
+            interpolation=methods.get(method, cv2.INTER_CUBIC)
         )
-        
-        # Convertir imagen
-        if isinstance(image, Image.Image):
-            img_array = np.array(image)
-        else:
-            img_array = image
-        
-        # Asegurar que es RGB
-        if len(img_array.shape) == 2:  # Grayscale
-            img_array = cv2.cvtColor(img_array, cv2.COLOR_GRAY2RGB)
-        elif img_array.shape[2] == 4:  # RGBA
-            img_array = cv2.cvtColor(img_array, cv2.COLOR_RGBA2RGB)
-        
-        # Convertir a BGR para OpenCV
-        img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
-        
-        # Upscale
-        output, _ = upsampler.enhance(img_bgr, outscale=scale_factor)
-        
-        # Convertir de vuelta a RGB
-        output_rgb = cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
-        
-        # Convertir a PIL Image
-        result = Image.fromarray(output_rgb)
-        
-        return result
-        
-    except Exception as e:
-        print(f"❌ Error durante el upscaling: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return image  # Devolver original si hay error
+    
+    # Aplicar sharpening
+    kernel = np.array([[-1, -1, -1],
+                       [-1,  9, -1],
+                       [-1, -1, -1]])
+    sharpened = cv2.filter2D(upscaled, -1, kernel)
+    
+    return Image.fromarray(sharpened)
 
-# ================== INTERFAZ GRADIO SIMPLIFICADA ==================
-def create_interface():
-    with gr.Blocks(title="🖼️ Mejorador de Imágenes AI", theme="soft") as app:
-        gr.Markdown("""
-        # 🚀 Mejorador de Imágenes con IA
-        ### Aumenta la resolución y calidad de tus imágenes usando Real-ESRGAN
-        
-        Sube una imagen y selecciona las opciones para mejorarla.
-        """)
+# Interfaz simple
+def create_simple_interface():
+    with gr.Blocks(title="Mejorador Simple de Imágenes") as app:
+        gr.Markdown("# 🖼️ Mejorador de Imágenes Simple")
         
         with gr.Row():
-            with gr.Column(scale=1):
-                input_image = gr.Image(
-                    type="pil",
-                    label="📤 Subir Imagen",
-                    height=300
-                )
-                
-                with gr.Accordion("⚙️ Configuración", open=True):
-                    model_select = gr.Dropdown(
-                        choices=[
-                            ("4x General (Recomendado)", "x4"),
-                            ("2x General", "x2"),
-                            ("4x Anime/Dibujos", "anime")
-                        ],
-                        value="x4",
-                        label="Modelo"
-                    )
-                    
-                    scale_slider = gr.Slider(
-                        minimum=1,
-                        maximum=4,
-                        value=4,
-                        step=1,
-                        label="Factor de Escala"
-                    )
+            with gr.Column():
+                input_img = gr.Image(type="pil", label="Imagen Original")
                 
-                process_btn = gr.Button(
-                    "✨ Mejorar Imagen",
-                    variant="primary",
-                    size="lg"
+                scale = gr.Slider(1, 8, 4, step=1, label="Factor de Escala")
+                method = gr.Dropdown(
+                    ['nearest', 'linear', 'cubic', 'lanczos'],
+                    value='cubic',
+                    label="Método de Interpolación"
                 )
                 
-                gr.Markdown("""
-                ### 💡 Consejos:
-                - Para fotos reales usa "4x General"
-                - Para dibujos/anime usa "4x Anime"
-                - El proceso puede tomar algunos segundos
-                """)
+                btn = gr.Button("Mejorar", variant="primary")
             
-            with gr.Column(scale=1):
-                output_image = gr.Image(
-                    type="pil",
-                    label="📥 Resultado Mejorado",
-                    height=300
-                )
-                
-                with gr.Accordion("📊 Información", open=False):
-                    info_text = gr.Markdown("Esperando imagen...")
+            with gr.Column():
+                output_img = gr.Image(type="pil", label="Imagen Mejorada")
         
-        # Ejemplos
-        gr.Examples(
-            examples=[
-                ["example1.jpg"],
-                ["example2.png"],
-            ],
-            inputs=[input_image],
-            label="💡 Ejemplos"
-        )
-        
-        # Funciones
-        def update_info(image, model, scale):
-            if image is None:
-                return "Sube una imagen para comenzar"
-            
-            orig_w, orig_h = image.size
-            new_w, new_h = orig_w * scale, orig_h * scale
-            
-            return f"""
-            **Imagen Original:** {orig_w} x {orig_h} px  
-            **Imagen Mejorada:** {new_w} x {new_h} px  
-            **Modelo:** {MODEL_CONFIGS[model]['name']}  
-            **Escala:** {scale}x
-            """
-        
-        def process_image(image, model, scale):
-            if image is None:
-                return None, "Por favor, sube una imagen"
-            
-            try:
-                result = upscale_image(image, model, scale)
-                info = update_info(image, model, scale)
-                return result, info
-            except Exception as e:
-                return None, f"Error: {str(e)}"
-        
-        # Conectar eventos
-        input_image.change(
-            fn=lambda img, mod, sc: update_info(img, mod, sc),
-            inputs=[input_image, model_select, scale_slider],
-            outputs=info_text
-        )
-        
-        model_select.change(
-            fn=lambda img, mod, sc: update_info(img, mod, sc),
-            inputs=[input_image, model_select, scale_slider],
-            outputs=info_text
-        )
-        
-        scale_slider.change(
-            fn=lambda img, mod, sc: update_info(img, mod, sc),
-            inputs=[input_image, model_select, scale_slider],
-            outputs=info_text
-        )
-        
-        process_btn.click(
-            fn=process_image,
-            inputs=[input_image, model_select, scale_slider],
-            outputs=[output_image, info_text]
+        btn.click(
+            fn=simple_upscale,
+            inputs=[input_img, scale, method],
+            outputs=output_img
         )
     
     return app
 
-# ================== ARCHIVO requirements.txt ==================
-# Crea un archivo requirements.txt con esto:
-"""
-torch>=1.9.0,<2.0.0
-torchvision>=0.10.0,<0.15.0
-gradio>=4.0.0
-opencv-python>=4.5.0
-numpy>=1.19.0
-Pillow>=8.0.0
-scipy>=1.6.0
-gdown>=4.4.0
-tqdm>=4.50.0
-basicsr==1.4.2
-realesrgan==0.3.0
-"""
-
-# ================== MAIN ==================
 if __name__ == "__main__":
-    # Crear la interfaz
-    app = create_interface()
-    
-    # Configurar para Hugging Face Spaces
-    share = os.getenv('SHARE', 'False').lower() == 'true'
-    
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=share,
-        debug=True
-    )
+    app = create_simple_interface()
+    app.launch()