Spaces:
Running
Running
File size: 3,749 Bytes
0db0341 4dc3d40 0db0341 35a7f8f 0db0341 51c8f60 4c45b50 95fc1cb 3ef5903 51c8f60 35a7f8f 51c8f60 3ef5903 216e8c5 51c8f60 3ef5903 51c8f60 4dc3d40 51c8f60 3ef5903 4dc3d40 3ef5903 51c8f60 3ef5903 0db0341 bd00297 0db0341 51c8f60 35a7f8f 51c8f60 35a7f8f 51c8f60 95fc1cb 51c8f60 35a7f8f 4dc3d40 0db0341 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
import gradio as gr
from PIL import Image
import os
import tempfile
def optimize_image(image):
# Leer la imagen original
img = Image.open(image)
# Calcular el tamaño del archivo original
original_size = os.path.getsize(image.name) / 1024 # tamaño en KB
# Ruta temporal para guardar las imágenes optimizadas
with tempfile.TemporaryDirectory() as tmpdirname:
# 1. Compresión sin pérdida
lossless_output_path = os.path.join(tmpdirname, "lossless.png")
img.save(lossless_output_path, format="PNG", optimize=True)
lossless_size = os.path.getsize(lossless_output_path) / 1024 # tamaño en KB
lossless_img = Image.open(lossless_output_path)
lossless_diff = original_size - lossless_size
# 2. Compresión con pérdida (reducción de calidad)
lossy_output_path = os.path.join(tmpdirname, "lossy.jpg")
img.save(lossy_output_path, format="JPEG", quality=50, optimize=True)
lossy_size = os.path.getsize(lossy_output_path) / 1024 # tamaño en KB
lossy_img = Image.open(lossy_output_path)
lossy_diff = original_size - lossy_size
# 3. Reducción de resolución
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)
reduced_size = os.path.getsize(reduced_output_path) / 1024 # tamaño en KB
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)
webp_lossy_size = os.path.getsize(webp_lossy_output_path) / 1024 # tamaño en KB
webp_lossy_img = Image.open(webp_lossy_output_path)
webp_lossy_diff = original_size - webp_lossy_size
# Retornar imágenes optimizadas y sus tamaños con la diferencia
return (lossless_img, f"Sin pérdida: {lossless_size:.2f} KB (diferencia: {-lossless_diff:.2f} KB)",
lossy_img, f"Con pérdida: {lossy_size:.2f} KB (diferencia: {-lossy_diff:.2f} KB)",
reduced_img, f"Reducción de resolución: {reduced_size:.2f} KB (diferencia: {-reduced_diff:.2f} KB)",
webp_lossy_img, f"WebP con pérdida: {webp_lossy_size:.2f} KB (diferencia: {-webp_lossy_diff:.2f} KB)")
# Interfaz de Gradio
with gr.Blocks() as demo:
gr.Markdown("### Optimización de imágenes para la web")
image_input = gr.File(label="Sube tu imagen", file_types=['image'])
optimize_button = gr.Button("Optimizar")
# Mostrar las imágenes optimizadas y sus tamaños
optimized_output1 = gr.Image(label="Optimización sin pérdida")
optimized_size1 = gr.Text(label="Tamaño del archivo sin pérdida")
optimized_output2 = gr.Image(label="Optimización con pérdida")
optimized_size2 = gr.Text(label="Tamaño del archivo con pérdida")
optimized_output3 = gr.Image(label="Reducción de resolución")
optimized_size3 = gr.Text(label="Tamaño del archivo con reducción de resolución")
optimized_output4 = gr.Image(label="Optimización WebP con pérdida")
optimized_size4 = gr.Text(label="Tamaño del archivo WebP con pérdida")
optimize_button.click(fn=optimize_image, inputs=image_input, outputs=[
optimized_output1, optimized_size1,
optimized_output2, optimized_size2,
optimized_output3, optimized_size3,
optimized_output4, optimized_size4
])
demo.launch()
|