Update app.py

app.py

@@ -3,37 +3,38 @@ from PIL import Image
 import os
 import tempfile
 
-def optimize_image(image):
+def optimize_image(image, png_optimize, jpeg_quality, jpeg_resolution, webp_quality):
     img = Image.open(image)
     
     original_size = os.path.getsize(image.name) / 1024  # tamaño en KB
     
     with tempfile.TemporaryDirectory() as tmpdirname:
-        # 1. Compresión sin pérdida
+        # 1. Compresión sin pérdida (PNG)
         lossless_output_path = os.path.join(tmpdirname, "lossless.png")
-        img.save(lossless_output_path, format="PNG", optimize=True)
+        img.save(lossless_output_path, format="PNG", optimize=png_optimize)
         lossless_size = os.path.getsize(lossless_output_path) / 1024
         lossless_img = Image.open(lossless_output_path)
         lossless_diff = original_size - lossless_size
         
         # 2. Compresión con pérdida (JPEG)
         lossy_output_path = os.path.join(tmpdirname, "lossy.jpg")
-        img.save(lossy_output_path, format="JPEG", quality=50, optimize=True)
+        img.save(lossy_output_path, format="JPEG", quality=jpeg_quality, optimize=True)
         lossy_size = os.path.getsize(lossy_output_path) / 1024
         lossy_img = Image.open(lossy_output_path)
         lossy_diff = original_size - lossy_size
         
-        # 3. Reducción de resolución
+        # 3. Reducción de resolución (JPEG)
         reduced_output_path = os.path.join(tmpdirname, "reduced_resolution.jpg")
-        reduced_img = img.resize((img.width // 2, img.height // 2), Image.LANCZOS)
-        reduced_img.save(reduced_output_path, format="JPEG", quality=85, optimize=True)
+        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
         reduced_img = Image.open(reduced_output_path)
         reduced_diff = original_size - reduced_size
 
         # 4. Compresión con WebP (con pérdida)
         webp_lossy_output_path = os.path.join(tmpdirname, "lossy.webp")
-        img.save(webp_lossy_output_path, format="WEBP", quality=50, optimize=True)
+        img.save(webp_lossy_output_path, format="WEBP", quality=webp_quality, optimize=True)
         webp_lossy_size = os.path.getsize(webp_lossy_output_path) / 1024
         webp_lossy_img = Image.open(webp_lossy_output_path)
         webp_lossy_diff = original_size - webp_lossy_size
@@ -47,7 +48,6 @@ def optimize_image(image):
         ]
 
 def download_image(file_path):
-    # Función para servir el archivo para descarga
     return gr.File.update(value=file_path, visible=True)
 
 with gr.Blocks() as demo:
@@ -59,32 +59,35 @@ with gr.Blocks() as demo:
     with gr.Row():
         with gr.Column():
             optimized_output1 = gr.Image(label="Optimización sin pérdida")
+            png_optimize = gr.Checkbox(label="Optimizar PNG", value=True)
             optimized_size1 = gr.Text()
             download_button1 = gr.Button("Descargar")
             download_file1 = gr.File()
 
         with gr.Column():
-            optimized_output2 = gr.Image(label="Optimización con pérdida")
+            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)
             optimized_size2 = gr.Text()
             download_button2 = gr.Button("Descargar")
             download_file2 = gr.File()
 
         with gr.Column():
-            optimized_output3 = gr.Image(label="Reducción de resolución")
+            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)
             optimized_size3 = gr.Text()
             download_button3 = gr.Button("Descargar")
             download_file3 = gr.File()
 
         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)
             optimized_size4 = gr.Text()
             download_button4 = gr.Button("Descargar")
             download_file4 = gr.File()
 
-    # Conectar la optimización con los outputs
     optimize_button.click(
         fn=optimize_image,
-        inputs=image_input,
+        inputs=[image_input, png_optimize, jpeg_quality, jpeg_resolution, webp_quality],
         outputs=[
             optimized_output1, optimized_size1, download_button1,
             optimized_output2, optimized_size2, download_button2,
@@ -93,7 +96,6 @@ with gr.Blocks() as demo:
         ]
     )
 
-    # Conectar los botones de descarga
     download_button1.click(download_image, inputs=download_button1, outputs=download_file1)
     download_button2.click(download_image, inputs=download_button2, outputs=download_file2)
     download_button3.click(download_image, inputs=download_button3, outputs=download_file3)