Update app.py

app.py

@@ -3,7 +3,7 @@ from PIL import Image
 import os
 import tempfile
 import pyheif
-from transformers import pipeline
+import ntpath
 
 def open_heic_image(image_path):
     heif_file = pyheif.read(image_path)
@@ -18,6 +18,10 @@ def open_heic_image(image_path):
     return img
 
 def optimize_image(image, png_optimize, jpeg_quality, jpeg_resolution, webp_quality):
+    # Obtener el nombre del archivo original sin la extensión
+    original_filename = ntpath.basename(image.name)
+    base_name, ext = os.path.splitext(original_filename)
+    
     # Manejar archivos HEIC
     if image.name.lower().endswith(".heic"):
         img = open_heic_image(image.name)
@@ -32,51 +36,50 @@ def optimize_image(image, png_optimize, jpeg_quality, jpeg_resolution, webp_qual
     output_dir = "/tmp/optimized_images"
     os.makedirs(output_dir, exist_ok=True)
     
+    # Lista para almacenar los resultados
     results = []
-    
+
     # Optimización para PNG
     if png_optimize:
-        lossless_output_path = os.path.join(output_dir, "lossless.png")
+        lossless_output_path = os.path.join(output_dir, f"{base_name}-lossless.png")
         img.save(lossless_output_path, format="PNG", optimize=True)
         lossless_size = os.path.getsize(lossless_output_path) / 1024
-        results.append(("PNG", lossless_output_path, lossless_size, original_size))
+        percent_reduction = 100 * (original_size - lossless_size) / original_size
+        results.append((Image.open(lossless_output_path), f"PNG: {lossless_size:.2f} KB (diferencia: {-percent_reduction:.2f} KB)", lossless_output_path))
 
     # Optimización para JPEG
-    lossy_output_path = os.path.join(output_dir, "lossy.jpg")
+    lossy_output_path = os.path.join(output_dir, f"{base_name}-lossy.jpg")
     img.save(lossy_output_path, format="JPEG", quality=jpeg_quality, optimize=True)
     lossy_size = os.path.getsize(lossy_output_path) / 1024
-    results.append(("JPEG", lossy_output_path, lossy_size, original_size))
+    percent_reduction = 100 * (original_size - lossy_size) / original_size
+    results.append((Image.open(lossy_output_path), f"JPEG: {lossy_size:.2f} KB (diferencia: {-percent_reduction:.2f} KB)", lossy_output_path))
 
     # Reducción de resolución (JPEG)
-    reduced_output_path = os.path.join(output_dir, "reduced_resolution.jpg")
+    reduced_output_path = os.path.join(output_dir, f"{base_name}-reduced_resolution.jpg")
     new_resolution = (img.width * jpeg_resolution // 100, img.height * jpeg_resolution // 100)
     reduced_img = img.resize(new_resolution, Image.LANCZOS)
     reduced_img.save(reduced_output_path, format="JPEG", quality=jpeg_quality, optimize=True)
     reduced_size = os.path.getsize(reduced_output_path) / 1024
-    results.append(("JPEG (resolución reducida)", reduced_output_path, reduced_size, original_size))
+    percent_reduction = 100 * (original_size - reduced_size) / original_size
+    results.append((Image.open(reduced_output_path), f"JPEG (resolución reducida): {reduced_size:.2f} KB (diferencia: {-percent_reduction:.2f} KB)", reduced_output_path))
 
     # Optimización para WebP
-    webp_lossy_output_path = os.path.join(output_dir, "lossy.webp")
+    webp_lossy_output_path = os.path.join(output_dir, f"{base_name}-lossy.webp")
     img.save(webp_lossy_output_path, format="WEBP", quality=webp_quality, optimize=True)
     webp_lossy_size = os.path.getsize(webp_lossy_output_path) / 1024
-    results.append(("WebP", webp_lossy_output_path, webp_lossy_size, original_size))
+    percent_reduction = 100 * (original_size - webp_lossy_size) / original_size
+    results.append((Image.open(webp_lossy_output_path), f"WebP: {webp_lossy_size:.2f} KB (diferencia: {-percent_reduction:.2f} KB)", webp_lossy_output_path))
+
+    # Asegurarse de que todos los resultados están presentes (4 entradas)
+    while len(results) < 4:
+        results.append((None, "", None))
     
-    # Preparar las salidas esperadas
+    # Dividir los resultados en imágenes, textos y rutas para descarga
     outputs = []
-    for format_name, path, size, original_size in results:
-        if format_name and path:
-            img = Image.open(path)
-            percent_reduction = 100 * (original_size - size) / original_size
-            outputs.extend([img, f"{format_name}: {size:.2f} KB\n(diferencia: {-percent_reduction:.2f} KB)", path])
-        else:
-            outputs.extend([None, "", None])
-    
-    return outputs
+    for result in results:
+        outputs.extend(result)
 
-# Función para aplicar un modelo seleccionado desde Hugging Face
-def apply_model(image, model_name):
-    model_pipeline = pipeline("image-super-resolution", model=model_name)
-    return model_pipeline(image)
+    return outputs
 
 with gr.Blocks() as demo:
     with gr.Tab("Optimización Tradicional"):
@@ -92,19 +95,19 @@ with gr.Blocks() as demo:
 
             with gr.Column():
                 optimized_output2 = gr.Image(label="Optimización con pérdida (JPEG)")
-                jpeg_quality = gr.Slider(label="Calidad JPEG", minimum=10, maximum=100, value=50, step=1)
+                jpeg_quality = gr.Slider(label="Calidad JPEG", minimum=10, maximum=100, value=75, step=1)
                 download_button2 = gr.File(label="Descargar", visible=True)
                 optimized_size2 = gr.Text(value="", interactive=False, show_label=False)
                 
             with gr.Column():
                 optimized_output3 = gr.Image(label="Reducción de resolución (JPEG)")
-                jpeg_resolution = gr.Slider(label="Resolución JPEG (%)", minimum=10, maximum=100, value=50, step=1)
+                jpeg_resolution = gr.Slider(label="Resolución JPEG (%)", minimum=10, maximum=100, value=75, step=1)
                 download_button3 = gr.File(label="Descargar", visible=True)
                 optimized_size3 = gr.Text(value="", interactive=False, show_label=False)
 
             with gr.Column():
                 optimized_output4 = gr.Image(label="Optimización WebP con pérdida")
-                webp_quality = gr.Slider(label="Calidad WebP", minimum=10, maximum=100, value=50, step=1)
+                webp_quality = gr.Slider(label="Calidad WebP", minimum=10, maximum=100, value=75, step=1)
                 download_button4 = gr.File(label="Descargar", visible=True)
                 optimized_size4 = gr.Text(value="", interactive=False, show_label=False)
 
@@ -120,20 +123,4 @@ with gr.Blocks() as demo:
             ]
         )
 
-    with gr.Tab("Optimización con Modelos de Hugging Face"):
-        hf_image_input = gr.File(label="Sube tu imagen para optimización avanzada", file_types=['image', '.heic'])
-        model_selector = gr.Dropdown(
-            label="Selecciona un modelo",
-            choices=["xinntao/Real-ESRGAN", "google/ddpm-cifar10-32", "facebook/ddpm"],  # Añade los modelos disponibles
-            value="xinntao/Real-ESRGAN"
-        )
-        hf_output = gr.Image(label="Resultado")
-        hf_button = gr.Button("Aplicar Modelo")
-
-        hf_button.click(
-            fn=apply_model,
-            inputs=[hf_image_input, model_selector],
-            outputs=hf_output
-        )
-
 demo.launch()