app.py

import gradio as gr
import numpy as np
from PIL import Image

def set_computer_params(computer):
    if computer == "Commodore 64":
        return 16, 4  # 16 niveles, pixelado moderado
    elif computer == "ZX Spectrum":
        return 8, 5  # 8 niveles, pixelado medio
    elif computer == "Amstrad CPC":
        return 16, 5  # 16 niveles, pixelado intermedio
    elif computer == "Atari 8-bit (400/800)":
        return 32, 6  # 32 niveles, pixelado más alto
    elif computer == "Apple II":
        return 6, 6  # 6 niveles, pixelado considerable
    elif computer == "MSX":
        return 16, 5  # 16 niveles, pixelado medio
    elif computer == "NES (Nintendo)":
        return 32, 4  # 32 niveles, pixelado moderado
    elif computer == "IBM PC CGA":
        return 4, 6  # 4 niveles, alto pixelado
    return 16, 4  # Valores predeterminados (Commodore 64)

def convert_to_pixelated_8bit(image, computer):
    if image is None:
        return None
    
    # Obtener los parámetros según la computadora retro
    intensity, pixelation_level = set_computer_params(computer)
    
    # Convertir la imagen a numpy array
    img_array = np.array(image)
    
    # Calcular los niveles por canal según la intensidad seleccionada
    levels = int(256 // intensity)
    
    # Reducir la cantidad de colores basada en la intensidad
    img_array = (img_array // levels) * levels
    
    # Ajustar ligeramente el contraste
    img_array = np.clip(img_array * 1.1, 0, 255).astype(np.uint8)
    
    # Aplicar el efecto de pixelado reduciendo y restaurando la resolución
    img_pil = Image.fromarray(img_array)
    
    # Obtener las dimensiones originales
    original_width, original_height = img_pil.size
    
    # Calcular el tamaño reducido para el pixelado
    pixel_width = max(1, original_width // pixelation_level)
    pixel_height = max(1, original_height // pixelation_level)
    
    # Redimensionar al tamaño más pequeño (pixelado) y luego de vuelta al tamaño original
    img_pil = img_pil.resize((pixel_width, pixel_height), Image.NEAREST)  # Reducir
    img_pil = img_pil.resize((original_width, original_height), Image.NEAREST)  # Volver al tamaño original
    
    return img_pil

def process_image(image, computer):
    if image is None:
        return None
    return convert_to_pixelated_8bit(Image.fromarray(image), computer)

# Crear la interfaz gráfica de Gradio
with gr.Blocks() as iface:
    gr.Markdown("# Emulador de Gráficos de Computadoras Retro")
    gr.Markdown("Sube una imagen, usa la cámara o emula el estilo gráfico de computadoras de los años 80 con 8 bits y pixelado. Elige entre varias computadoras retro.")
    
    with gr.Row():
        with gr.Column():
            input_image = gr.Image(source="upload", type="numpy", label="Subir Imagen")
            camera_input = gr.Image(source="webcam", type="numpy", label="Usar Cámara")
            capture_button = gr.Button("Capturar Imagen")
        
        computer_dropdown = gr.Dropdown(
            ["Commodore 64", "ZX Spectrum", "Amstrad CPC", "Atari 8-bit (400/800)", "Apple II", "MSX", "NES (Nintendo)", "IBM PC CGA"],
            label="Elige una computadora retro",
            value="Commodore 64"
        )
    
    output_image = gr.Image(type="numpy", label="Imagen convertida")
    
    convert_button = gr.Button("Convertir Imagen")
    
    # Conexiones
    convert_button.click(
        process_image,
        inputs=[input_image, computer_dropdown],
        outputs=output_image
    )
    
    capture_button.click(
        lambda x: x,
        inputs=camera_input,
        outputs=input_image
    )
    
    gr.Markdown("Hecho con ❤️ en MDQ por Peláez")

iface.launch()