Upload 2 files

main_resize.py

@@ -0,0 +1,287 @@
+import gradio as gr
+import numpy as np
+import cv2
+from PIL import Image
+import os
+import shutil # Para manejar directorios y archivos
+
+# Importa tu módulo resize_utils
+# Asegúrate de que 'app' sea el paquete correcto o ajusta la importación
+from app.resize_utils import resize_image_for_print
+
+# --- Tema y CSS personalizados ---
+theme = gr.themes.Default(
+    primary_hue=gr.themes.Color(
+        c50="#e0f2f7", c100="#b3e1ef", c200="#80cee7", c300="#4dbbde", c400="#26ace0",
+        c500="#034077", # Tu azul principal
+        c600="#023768", c700="#022e59", c800="#01254a", c900="#011b3b", c950="#000f22"
+    ),
+    secondary_hue=gr.themes.Color(
+        c50="#f9fafb", c100="#f4f6f8", c200="#e9ecef", c300="#dee2e6", c400="#ced4da",
+        c500="#adb5bd", c600="#889096", c700="#6c757d", c800="#495057", c900="#343a40",
+        c950="#212529"
+    ),
+    neutral_hue=gr.themes.Color(
+        c50="#f8f9fa", c100="#f1f3f5", c200="#e9ecef", c300="#dee2e6", c400="#ced4da",
+        c500="#adb5bd", c600="#889096", c700="#6c757d", c800="#495057", c900="#343a40",
+        c950="#212529"
+    )
+).set(
+    button_primary_background_fill="#034077",
+    button_primary_background_fill_hover="#023768",
+    button_primary_text_color="white",
+    checkbox_background_color_selected="#034077",
+    checkbox_border_color_selected="#034077",
+    slider_color="#034077",
+)
+
+css = """
+body {
+    background-color: #f0f2f5;
+}
+.gradio-container {
+    max-width: 1200px;
+    margin: 30px auto;
+    border-radius: 15px;
+    box-shadow: 0 10px 30px rgba(0, 0, 0, 0.1);
+    background-color: white;
+    overflow: hidden;
+}
+h1 {
+    color: #034077;
+    text-align: center;
+    padding-top: 20px;
+    margin-bottom: 20px;
+    font-size: 2.5em;
+    font-weight: 700;
+}
+.gr-text-input, .gr-slider {
+    border-radius: 8px;
+}
+.gr-button.primary {
+    border-radius: 10px;
+    font-weight: bold;
+    padding: 10px 20px;
+    font-size: 1.1em;
+    transition: all 0.3s ease;
+}
+.gr-button.primary:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 10px rgba(0, 0, 0, 0.2);
+}
+.gr-checkbox-group label {
+    font-weight: 500;
+}
+.gr-accordion {
+    border-radius: 10px;
+    border: 1px solid #e0e0e0;
+    margin-bottom: 15px;
+    background-color: #ffffff;
+}
+.gr-accordion.open > .gr-accordion-header {
+    border-bottom: 1px solid #e0e0e0;
+}
+.gr-accordion-header {
+    background-color: #f8f8f8;
+    border-top-left-radius: 10px;
+    border-top-right-radius: 10px;
+    padding: 15px;
+    font-weight: bold;
+    color: #034077;
+    font-size: 1.1em;
+}
+.gr-accordion-content .gr-checkbox label,
+.gr-accordion-content .gr-slider label,
+.gr-accordion-content .gr-textbox label {
+    color: #333333;
+    font-weight: 500;
+    margin-bottom: 5px;
+}
+.gr-image {
+    border: 1px solid #e0e0e0;
+    border-radius: 10px;
+    background-color: #fdfdfd;
+}
+.output_image_label {
+    text-align: center;
+    font-weight: bold;
+    color: #034077;
+    margin-top: 10px;
+    font-size: 1.2em;
+}
+"""
+
+# Directorio temporal para guardar los resultados
+OUTPUT_DIR = "resized_images_output"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def process_images_for_print(
+    image_files: list, # Ahora espera una lista de archivos
+    input_folder: str, # Ruta a una carpeta
+    target_dpi: int,
+    longest_side_cm: float
+) -> tuple: # Devolverá un listado de archivos para descarga y un mensaje
+    """
+    Procesa una o varias imágenes (o una carpeta) para redimensionar y guarda como TIFF.
+    """
+    processed_file_paths = []
+    output_messages = []
+
+    # Limpiar el directorio de salida antes de cada procesamiento
+    # Comentar esta línea si deseas que los archivos se acumulen entre ejecuciones.
+    # Pero para una interfaz de usuario limpia, es mejor borrarlos.
+    if os.path.exists(OUTPUT_DIR):
+        shutil.rmtree(OUTPUT_DIR)
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    images_to_process = []
+
+    # Manejar entrada de carpeta
+    if input_folder and os.path.isdir(input_folder):
+        output_messages.append(f"Procesando imágenes de la carpeta: {input_folder}")
+        for filename in os.listdir(input_folder):
+            file_path = os.path.join(input_folder, filename)
+            if os.path.isfile(file_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff', '.tif')):
+                images_to_process.append(file_path)
+    
+    # Manejar entrada de múltiples archivos (si no se seleccionó carpeta o si también hay archivos individuales)
+    # Si se seleccionaron archivos individuales, se añaden a la lista.
+    # Gradio `gr.File(file_count="multiple")` devuelve una lista de objetos `tempfile.NamedTemporaryFile`
+    if image_files:
+        for img_obj in image_files:
+            if img_obj is not None:
+                images_to_process.append(img_obj.name) # Usar el atributo .name para obtener la ruta del archivo temporal
+
+    if not images_to_process:
+        raise gr.Error("Por favor, sube al menos una imagen o selecciona una carpeta con imágenes.")
+
+    for i, img_path in enumerate(images_to_process):
+        try:
+            # Obtener el nombre original del archivo desde la ruta
+            original_filename_ext = os.path.basename(img_path)
+            original_filename_no_ext = os.path.splitext(original_filename_ext)[0]
+
+            # Abrir la imagen con PIL
+            original_pil_img = Image.open(img_path)
+
+            # Convertir a BGR numpy array para resize_image_for_print
+            img_np_rgb = np.array(original_pil_img)
+            img_np_bgr = cv2.cvtColor(img_np_rgb, cv2.COLOR_RGB2BGR)
+
+            # Aplicar redimensionamiento
+            resized_np_bgr = resize_image_for_print(
+                img_np_bgr,
+                target_dpi=target_dpi,
+                target_long_side_cm=longest_side_cm
+            )
+
+            # Convertir de nuevo a PIL Image para guardar como TIFF con DPI
+            resized_pil_rgb = Image.fromarray(cv2.cvtColor(resized_np_bgr, cv2.COLOR_BGR2RGB))
+
+            # Guardar la imagen en formato TIFF con la información de DPI
+            output_filename = f"{original_filename_no_ext}_resized.tiff"
+            output_filepath = os.path.join(OUTPUT_DIR, output_filename)
+            
+            # PIL guarda DPI en puntos por pulgada (dots per inch)
+            # Asegúrate de que los metadatos de DPI se establezcan correctamente al guardar
+            resized_pil_rgb.save(output_filepath, dpi=(target_dpi, target_dpi))
+            processed_file_paths.append(output_filepath)
+            output_messages.append(f"✅ Procesado: {original_filename_ext} -> {output_filename}")
+
+        except Exception as e:
+            output_messages.append(f"❌ Error al procesar {os.path.basename(img_path)}: {e}")
+            print(f"Error processing {img_path}: {e}")
+
+    if not processed_file_paths:
+        raise gr.Error("No se pudo procesar ninguna imagen. Revisa los archivos de entrada y los parámetros.")
+    
+    # Gradio requiere que se devuelva una lista de rutas de archivo para gr.File(file_count="multiple")
+    # Y un mensaje para el Textbox
+    return processed_file_paths, "\n".join(output_messages)
+
+
+with gr.Blocks(theme=theme, css=css, title="Redimensionador de Imágenes para Impresión") as demo:
+    gr.Markdown(
+        """
+        # 🖼️ **Redimensionador de Imágenes para Impresión**
+        Sube tus imágenes o una carpeta, define los parámetros de impresión y obtén tus imágenes redimensionadas en formato TIFF.
+        """
+    )
+    with gr.Row():
+        with gr.Column(scale=1):
+            with gr.Group(elem_classes="input-card"):
+                gr.Markdown("## ⬆️ **Cargar Imágenes**")
+                
+                # Opción para subir múltiples archivos
+                image_files_input = gr.File(
+                    label="Seleccionar una o varias imágenes",
+                    file_count="multiple", # Permite múltiples archivos
+                    type="filepath", # *** CORREGIDO A 'filepath' ***
+                    file_types=[".png", ".jpg", ".jpeg", ".bmp", ".tiff", ".tif"],
+                    height=200
+                )
+                gr.Markdown("---")
+                # Opción para seleccionar una carpeta
+                input_folder_path = gr.Textbox(
+                    label="O ingresar la ruta a una carpeta con imágenes",
+                    placeholder="Ej: /ruta/a/mis/fotos (dejar en blanco si subes archivos)",
+                    interactive=True
+                )
+                gr.Markdown("*(Si seleccionas archivos y una carpeta, se procesarán AMBOS.)*")
+
+            with gr.Group(elem_classes="options-card"):
+                gr.Markdown("## ⚙️ **Parámetros de Impresión**")
+
+                longest_side_cm = gr.Slider(
+                    minimum=1, maximum=200, step=1, value=50,
+                    label="Lado más largo (cm)",
+                    info="Define el tamaño físico del lado más largo de la imagen resultante en centímetros.",
+                    interactive=True
+                )
+                target_dpi = gr.Slider(
+                    minimum=72, maximum=1200, step=10, value=300,
+                    label="DPI (Puntos por pulgada)",
+                    info="Resolución deseada para impresión (300 DPI es estándar para alta calidad).",
+                    interactive=True
+                )
+            
+            process_button = gr.Button("¡Redimensionar y Guardar como TIFF! 🚀", variant="primary", scale=0)
+
+        with gr.Column(scale=1):
+            with gr.Group(elem_classes="output-card"):
+                gr.Markdown("## ✅ **Resultados Procesados**")
+                
+                # Para mostrar el estado del procesamiento
+                status_output = gr.Textbox(
+                    label="Estado del Proceso",
+                    lines=10,
+                    interactive=False,
+                    max_lines=20,
+                    show_copy_button=True
+                )
+
+                # Para descargar los archivos procesados
+                output_files = gr.File(
+                    label="Imágenes TIFF Redimensionadas",
+                    file_count="multiple", # Permite descargar múltiples archivos
+                    type="filepath", # *** CORREGIDO A 'filepath' ***
+                    interactive=False # No permite al usuario subir archivos aquí
+                )
+                gr.Markdown("---")
+                gr.Markdown("✨*Tus imágenes redimensionadas aparecerán aquí. Haz clic para descargar.*")
+
+    # Acción del botón
+    process_button.click(
+        fn=process_images_for_print,
+        inputs=[
+            image_files_input,
+            input_folder_path,
+            target_dpi,
+            longest_side_cm
+        ],
+        outputs=[output_files, status_output]
+    )
+
+# FastAPI + Uvicorn
+if __name__ == '__main__':
+    demo.launch(debug=True, show_api=False, server_name="0.0.0.0", server_port=7860)

resize_utils.py

@@ -0,0 +1,55 @@
+from PIL import Image
+import numpy as np
+import cv2 # Necesario si vas a trabajar con np arrays en BGR
+
+def resize_image_for_print(image_np_bgr, target_dpi=300, target_long_side_cm=50):
+    """
+    Redimensiona una imagen (numpy array BGR) para impresión a una resolución de 300 dpi
+    y un lado más largo de 50 cm, sin alterar la estética.
+
+    Args:
+        image_np_bgr (np.ndarray): Imagen de entrada en formato NumPy BGR.
+        target_dpi (int): Resolución deseada en DPI (píxeles por pulgada).
+        target_long_side_cm (float): Longitud deseada del lado más largo en centímetros.
+    
+    Returns:
+        np.ndarray: La imagen redimensionada en formato NumPy BGR.
+    """
+    if not isinstance(image_np_bgr, np.ndarray):
+        raise TypeError("La entrada debe ser un array de NumPy BGR.")
+    
+    # Convertir de BGR a RGB para PIL si fuera necesario, pero PIL puede trabajar con arrays directamente
+    # Para simplicidad y consistencia, vamos a pasar de NumPy BGR a PIL RGB y luego de vuelta a NumPy BGR.
+    img_pil_rgb = Image.fromarray(cv2.cvtColor(image_np_bgr, cv2.COLOR_BGR2RGB))
+
+    # 1. Calcular el tamaño en píxeles basado en el lado más largo deseado y el DPI
+    # 1 pulgada = 2.54 cm
+    target_long_side_inches = target_long_side_cm / 2.54
+    target_long_side_pixels = int(target_long_side_inches * target_dpi)
+
+    # Obtener el ancho y alto actuales de la imagen PIL
+    width, height = img_pil_rgb.size
+
+    # Determinar cuál es el lado más largo de la imagen original
+    if width > height:
+        # El ancho es el lado más largo
+        new_width = target_long_side_pixels
+        new_height = int(height * (new_width / width))
+    else:
+        # El alto es el lado más largo (o son iguales)
+        new_height = target_long_side_pixels
+        new_width = int(width * (new_height / height))
+
+    # 2. Redimensionar la imagen usando un filtro de alta calidad
+    resized_img_pil_rgb = img_pil_rgb.resize((new_width, new_height), Image.LANCZOS)
+
+    # Convertir de nuevo a NumPy BGR
+    resized_np_rgb = np.array(resized_img_pil_rgb)
+    resized_np_bgr = cv2.cvtColor(resized_np_rgb, cv2.COLOR_RGB2BGR)
+
+    # Nota: Los metadatos de DPI no se pueden "incrustar" directamente en un np.ndarray.
+    # Si realmente necesitas guardarlo con DPI para impresión, la función de guardado
+    # debe hacerse fuera de aquí, quizás en el main.py cuando se exporta el resultado final.
+    # Por ahora, esta función solo devuelve la imagen redimensionada.
+    
+    return resized_np_bgr