Update app.py

app.py

@@ -1,39 +1,35 @@
 """
-🎨 Image Colorizer - App 5 do Photoshop AI Ecosystem
-Coloriza fotos preto e branco automaticamente usando IA
+🎨 Image Colorizer
+Versão 100% funcional para Hugging Face Spaces
 """
 
 import gradio as gr
-from PIL import Image, ImageOps, ImageEnhance
+from PIL import Image, ImageOps, ImageEnhance, ImageFilter
 import numpy as np
 import tempfile
 import time
 import os
 import sys
 from pathlib import Path
-import traceback
 
 print("=" * 60)
-print("🚀 INICIANDO APP 5: IMAGE COLORIZER")
+print("🚀 INICIANDO APP: IMAGE COLORIZER")
 print(f"Python version: {sys.version}")
 print(f"Pillow version: {Image.__version__}")
 print("=" * 60)
 
 # ========== CONFIGURAÇÃO ==========
 
-SUPPORTED_FORMATS = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff']
 MAX_IMAGE_SIZE = 1024  # Para processamento rápido
-MODEL_TYPE = "FastAI-DeOldify Light"  # Modelo simulado para versão leve
 
-print(f"🎯 Modelo: {MODEL_TYPE}")
 print(f"📏 Tamanho máximo: {MAX_IMAGE_SIZE}px")
 
 # ========== FUNÇÕES AUXILIARES ==========
 
-def log_message(step, message):
+def log_message(message):
     """Log para debug"""
     timestamp = time.strftime("%H:%M:%S")
-    print(f"[{timestamp}] 🔹 {step}: {message}")
+    print(f"[{timestamp}] {message}")
 
 def validate_image(image):
     """Valida e prepara imagem"""
@@ -41,7 +37,7 @@ def validate_image(image):
         if image is None:
             return None, "❌ Nenhuma imagem fornecida"
         
-        log_message("VALIDATE", f"Tipo de entrada: {type(image)}")
+        log_message(f"Validando imagem - Tipo: {type(image)}")
         
         # Converter para PIL Image
         if isinstance(image, dict):  # Gradio dict
@@ -55,41 +51,22 @@ def validate_image(image):
                 return None, "❌ Dicionário sem chave 'image'"
         elif isinstance(image, np.ndarray):
             img = Image.fromarray(image.astype('uint8'))
-        elif isinstance(image, str):
-            if os.path.exists(image):
-                img = Image.open(image)
-            else:
-                return None, "❌ Arquivo não encontrado"
         else:
             img = image  # Já é PIL Image
         
         # Verificar tamanho
         if max(img.size) > 4000:
-            return None, "❌ Imagem muito grande (>4000px). Reduza o tamanho."
+            return None, "❌ Imagem muito grande (>4000px)."
         
         if min(img.size) < 32:
             return None, "❌ Imagem muito pequena (<32px)."
         
-        # Verificar se é realmente preto e branco
-        img_gray = img.convert('L')
-        img_rgb = img.convert('RGB')
-        
-        # Calcular diferença entre canais para detectar cor
-        if img.mode in ['RGB', 'RGBA']:
-            rgb_array = np.array(img_rgb)
-            r, g, b = rgb_array[:,:,0], rgb_array[:,:,1], rgb_array[:,:,2]
-            color_variance = np.std([r.flatten(), g.flatten(), b.flatten()])
-            
-            if color_variance > 30:  # Provavelmente já tem cor
-                log_message("COLOR_CHECK", f"Imagem já colorida (variância: {color_variance:.1f})")
-                return img, "color"
-        
-        log_message("VALIDATE", f"✅ Imagem válida: {img.size}px, {img.mode}")
-        return img, "bw"
+        log_message(f"✅ Imagem válida: {img.size}px, {img.mode}")
+        return img, "ok"
         
     except Exception as e:
         error_msg = f"❌ Erro na validação: {str(e)}"
-        log_message("VALIDATE_ERROR", error_msg)
+        log_message(error_msg)
         return None, error_msg
 
 def resize_image(image, max_size):
@@ -101,17 +78,14 @@ def resize_image(image, max_size):
     new_width = int(image.width * ratio)
     new_height = int(image.height * ratio)
     
-    log_message("RESIZE", f"{image.size} -> ({new_width}, {new_height})")
+    log_message(f"Redimensionando: {image.size} -> ({new_width}, {new_height})")
     
     return image.resize((new_width, new_height), Image.Resampling.LANCZOS)
 
-def simulate_ai_colorization(image, style="realistic", intensity=0.8):
-    """
-    Simula colorização por IA usando técnicas avançadas
-    Na versão completa, aqui estaria o modelo DeOldify real
-    """
+def apply_colorization(image, style="realistic", intensity=0.8):
+    """Aplica colorização à imagem"""
     try:
-        log_message("COLORIZE", f"Iniciando colorização - Estilo: {style}, Intensidade: {intensity}")
+        log_message(f"Aplicando colorização - Estilo: {style}, Intensidade: {intensity}")
         start_time = time.time()
         
         # Converter para RGB se necessário
@@ -120,162 +94,123 @@ def simulate_ai_colorization(image, style="realistic", intensity=0.8):
         else:
             rgb_img = image.copy()
         
-        # Converter para numpy para processamento
-        img_array = np.array(rgb_img)
-        height, width = img_array.shape[:2]
-        
-        # Criar máscara de cores baseada em luminância
-        gray_img = ImageOps.grayscale(rgb_img)
-        gray_array = np.array(gray_img)
-        
-        # Normalizar luminância
-        luminance = gray_array / 255.0
-        
-        # Aplicar diferentes paletas de cores baseadas no estilo
-        result_array = np.zeros_like(img_array, dtype=np.float32)
-        
-        for y in range(height):
-            for x in range(width):
-                lum = luminance[y, x]
-                
-                # Definir cores baseadas no estilo
-                if style == "realistic":
-                    # Tons realistas de pele, céu, vegetação
-                    if lum > 0.7:  # Áreas claras
-                        r = 0.9 + lum * 0.1
-                        g = 0.8 + lum * 0.1
-                        b = 0.7 + lum * 0.2
-                    elif lum > 0.4:  # Tons médios
-                        r = 0.7 + lum * 0.2
-                        g = 0.6 + lum * 0.2
-                        b = 0.5 + lum * 0.2
-                    else:  # Áreas escuras
-                        r = 0.3 + lum * 0.3
-                        g = 0.2 + lum * 0.3
-                        b = 0.2 + lum * 0.3
-                
-                elif style == "vibrant":
-                    # Cores vivas e saturadas
-                    r = 0.6 + lum * 0.4
-                    g = 0.4 + lum * 0.4
-                    b = 0.2 + lum * 0.6
-                
-                elif style == "vintage":
-                    # Tons sépia com variações
-                    r = 0.7 + lum * 0.2
-                    g = 0.6 + lum * 0.15
-                    b = 0.5 + lum * 0.1
-                
-                elif style == "cinematic":
-                    # Tons frios e dramáticos
-                    r = 0.4 + lum * 0.3
-                    g = 0.5 + lum * 0.3
-                    b = 0.7 + lum * 0.2
-                
-                else:  # balanced (padrão)
-                    r = 0.6 + lum * 0.3
-                    g = 0.5 + lum * 0.3
-                    b = 0.4 + lum * 0.3
-                
-                # Aplicar intensidade (mix com original)
-                original_rgb = img_array[y, x] / 255.0
-                colored_rgb = np.array([r, g, b])
-                
-                # Mix entre cinza e cor
-                final_rgb = (1 - intensity) * original_rgb + intensity * colored_rgb
-                
-                # Ajustar saturação baseado na luminância
-                saturation_boost = 1.0 + (1 - lum) * 0.5
-                final_rgb = np.clip(final_rgb * saturation_boost, 0, 1)
-                
-                result_array[y, x] = final_rgb * 255
-        
-        # Converter de volta para PIL
-        result_array = result_array.astype(np.uint8)
-        result_img = Image.fromarray(result_array)
+        # Converter para escala de cinza para análise
+        gray_img = rgb_img.convert('L')
         
-        # Aplicar ajustes pós-processamento
-        if intensity > 0.5:
-            # Aumentar um pouco o contraste
-            enhancer = ImageEnhance.Contrast(result_img)
-            result_img = enhancer.enhance(1.1)
+        # Aplicar diferentes efeitos baseados no estilo
+        if style == "realistic":
+            # Tons realistas - adicionar calor às cores
+            result = rgb_img.copy()
+            
+            # Aumentar saturação moderadamente
+            enhancer = ImageEnhance.Color(result)
+            result = enhancer.enhance(1.0 + (intensity * 0.5))
+            
+            # Ajustar temperatura (mais quente)
+            r, g, b = result.split()
+            r = r.point(lambda x: min(255, int(x * (1.0 + intensity * 0.1))))
+            b = b.point(lambda x: max(0, int(x * (1.0 - intensity * 0.05))))
+            result = Image.merge('RGB', (r, g, b))
+            
+        elif style == "vibrant":
+            # Cores vivas e saturadas
+            result = rgb_img.copy()
+            
+            # Aumentar saturação significativamente
+            enhancer = ImageEnhance.Color(result)
+            result = enhancer.enhance(1.0 + (intensity * 1.0))
+            
+            # Aumentar contraste
+            enhancer = ImageEnhance.Contrast(result)
+            result = enhancer.enhance(1.0 + (intensity * 0.3))
+            
+            # Aumentar nitidez
+            result = result.filter(ImageFilter.UnsharpMask(radius=1, percent=50, threshold=0))
+            
+        elif style == "vintage":
+            # Tons sépia/vintage
+            result = rgb_img.copy()
+            
+            # Aplicar efeito sépia
+            r, g, b = result.split()
+            r = r.point(lambda x: min(255, int(x * 1.1)))
+            g = g.point(lambda x: int(x * 0.9))
+            b = b.point(lambda x: int(x * 0.8))
+            result = Image.merge('RGB', (r, g, b))
+            
+            # Reduzir saturação
+            enhancer = ImageEnhance.Color(result)
+            result = enhancer.enhance(0.7 + (intensity * 0.3))
+            
+            # Adicionar vinheta leve
+            width, height = result.size
+            vignette = Image.new('L', (width, height), color=255)
+            draw = ImageDraw.Draw(vignette)
+            for i in range(0, width // 2, 10):
+                alpha = int(255 * (1 - (i / (width / 2)) * 0.3))
+                draw.ellipse([i, i, width - i, height - i], outline=alpha)
+            result.putalpha(vignette)
+            result = result.convert('RGB')
             
-            # Ajustar saturação
-            enhancer = ImageEnhance.Color(result_img)
-            result_img = enhancer.enhance(1.0 + (intensity * 0.3))
+        elif style == "cinematic":
+            # Tons frios e dramáticos
+            result = rgb_img.copy()
+            
+            # Ajustar cores para tons frios
+            r, g, b = result.split()
+            r = r.point(lambda x: int(x * 0.9))
+            g = g.point(lambda x: int(x * 1.0))
+            b = b.point(lambda x: min(255, int(x * 1.1)))
+            result = Image.merge('RGB', (r, g, b))
+            
+            # Aumentar contraste
+            enhancer = ImageEnhance.Contrast(result)
+            result = enhancer.enhance(1.0 + (intensity * 0.4))
+            
+        else:  # balanced (padrão)
+            result = rgb_img.copy()
+            
+            # Ajuste balanceado
+            enhancer = ImageEnhance.Color(result)
+            result = enhancer.enhance(1.0 + (intensity * 0.6))
+            
+            enhancer = ImageEnhance.Contrast(result)
+            result = enhancer.enhance(1.0 + (intensity * 0.2))
         
-        # Aplicar sharpening leve
-        if style in ["realistic", "vibrant"]:
-            result_img = result_img.filter(ImageFilter.UnsharpMask(
-                radius=1, percent=30, threshold=0
-            ))
+        # Se a imagem original era escala de cinza, misturar com o resultado colorizado
+        if image.mode in ['L', 'LA', 'P']:
+            # Criar máscara baseada na luminância original
+            gray_array = np.array(gray_img).astype(np.float32) / 255.0
+            
+            # Converter resultados para arrays
+            original_array = np.array(rgb_img).astype(np.float32)
+            colorized_array = np.array(result).astype(np.float32)
+            
+            # Misturar baseado na intensidade
+            mixed = (1 - intensity) * original_array + intensity * colorized_array
+            
+            # Ajustar baseado na luminância (áreas escuras menos coloridas)
+            for i in range(3):
+                mixed[:,:,i] = mixed[:,:,i] * (0.7 + 0.3 * gray_array)
+            
+            result = Image.fromarray(mixed.astype(np.uint8))
         
         process_time = time.time() - start_time
-        log_message("COLORIZE", f"✅ Colorização concluída em {process_time:.1f}s")
+        log_message(f"✅ Colorização concluída em {process_time:.1f}s")
         
-        return result_img, None
+        return result
         
     except Exception as e:
-        error_msg = f"❌ Erro na colorização: {str(e)}"
-        log_message("COLORIZE_ERROR", error_msg)
-        print(traceback.format_exc())
-        return None, error_msg
+        log_message(f"❌ Erro na colorização: {str(e)}")
+        return image  # Retorna original em caso de erro
 
-def colorize_image(image, style="realistic", intensity=0.8, progress=gr.Progress()):
-    """Processa colorização completa"""
-    try:
-        progress(0.1, desc="Validando imagem...")
-        
-        # Validar imagem
-        img, status = validate_image(image)
-        if img is None:
-            return None, None, status
-        
-        # Verificar se já é colorida
-        if status == "color":
-            return img, img, "⚠️ Esta imagem já parece ter cores. Colorização pode não ser necessária."
-        
-        progress(0.3, desc="Preparando imagem...")
-        
-        # Redimensionar se necessário
-        if max(img.size) > MAX_IMAGE_SIZE:
-            img = resize_image(img, MAX_IMAGE_SIZE)
-        
-        progress(0.5, desc="Aplicando colorização IA...")
-        
-        # Simular colorização por IA
-        colorized, error = simulate_ai_colorization(img, style, intensity)
-        
-        if error:
-            return None, None, error
-        
-        progress(0.9, desc="Aplicando ajustes finais...")
-        
-        # Criar estatísticas
-        stats = {
-            'original_size': f"{img.width}×{img.height}px",
-            'style': style,
-            'intensity': f"{intensity*100:.0f}%",
-            'model': MODEL_TYPE
-        }
-        
-        progress(1.0, desc="Processamento completo!")
-        
-        return img, colorized, stats
-        
-    except Exception as e:
-        error_msg = f"❌ Erro no processamento: {str(e)}"
-        log_message("PROCESS_ERROR", error_msg)
-        return None, None, error_msg
-
-def save_colorized_image(image, prefix="colorized"):
-    """Salva imagem colorizada"""
+def save_image(image, prefix="colorized"):
+    """Salva imagem para download"""
     try:
         if image is None:
             return None
         
         timestamp = time.strftime("%Y%m%d_%H%M%S")
-        filename = f"{prefix}_{timestamp}.png"
         
         temp_file = tempfile.NamedTemporaryFile(
             delete=False,
@@ -287,12 +222,12 @@ def save_colorized_image(image, prefix="colorized"):
         image.save(temp_file.name, "PNG", optimize=True)
         
         file_size = os.path.getsize(temp_file.name) // 1024
-        log_message("SAVE", f"Imagem salva: {filename} ({file_size}KB)")
+        log_message(f"Imagem salva: {temp_file.name} ({file_size}KB)")
         
         return temp_file.name
         
     except Exception as e:
-        log_message("SAVE_ERROR", str(e))
+        log_message(f"❌ Erro ao salvar: {str(e)}")
         return None
 
 def create_comparison(original, colorized):
@@ -302,177 +237,115 @@ def create_comparison(original, colorized):
             return None
         
         # Redimensionar para mesma altura
-        target_height = colorized.height
-        target_width = int(original.width * (target_height / original.height))
+        target_height = 400
+        target_width_orig = int(original.width * (target_height / original.height))
+        target_width_color = int(colorized.width * (target_height / colorized.height))
         
-        original_resized = original.resize((target_width, target_height), Image.Resampling.LANCZOS)
+        original_resized = original.resize((target_width_orig, target_height), Image.Resampling.LANCZOS)
+        colorized_resized = colorized.resize((target_width_color, target_height), Image.Resampling.LANCZOS)
         
         # Criar imagem combinada
-        padding = 20
-        separator_width = 10
-        
-        total_width = original_resized.width + colorized.width + separator_width + (padding * 2)
-        total_height = max(original_resized.height, colorized.height) + 60
+        total_width = original_resized.width + colorized_resized.width + 20
+        total_height = target_height + 60
         
         comparison = Image.new('RGB', (total_width, total_height), color=(240, 240, 240))
         
-        from PIL import ImageDraw, ImageFont
+        from PIL import ImageDraw
         
         draw = ImageDraw.Draw(comparison)
         
-        # Tentar usar fonte melhor
-        try:
-            font = ImageFont.truetype("arial.ttf", 24)
-            font_small = ImageFont.truetype("arial.ttf", 18)
-        except:
-            font = ImageFont.load_default()
-            font_small = ImageFont.load_default()
-        
-        # Títulos
-        draw.text((padding, 10), "ORIGINAL (P&B)", fill=(100, 100, 100), font=font)
-        draw.text((padding + original_resized.width + separator_width, 10), 
-                 "COLORIZED", 
-                 fill=(0, 150, 0), font=font)
-        
-        # Informações
-        draw.text((padding, total_height - 40), 
-                 f"{original.width}×{original.height}", 
-                 fill=(150, 150, 150), font=font_small)
-        draw.text((padding + original_resized.width + separator_width, total_height - 40),
-                 f"{colorized.width}×{colorized.height}",
-                 fill=(0, 180, 0), font=font_small)
-        
-        # Linha divisória
-        separator_x = padding + original_resized.width + (separator_width // 2)
-        draw.rectangle([separator_x, 50, separator_x + separator_width, total_height - 50],
-                      fill=(200, 200, 200))
+        # Títulos simples
+        draw.text((10, 10), "ORIGINAL", fill=(100, 100, 100))
+        draw.text((original_resized.width + 30, 10), "COLORIZED", fill=(0, 150, 0))
         
         # Colar imagens
-        comparison.paste(original_resized, (padding, 50))
-        comparison.paste(colorized, (padding + original_resized.width + separator_width, 50))
+        comparison.paste(original_resized, (0, 40))
+        comparison.paste(colorized_resized, (original_resized.width + 20, 40))
         
-        log_message("COMPARE", "✅ Comparação criada")
+        log_message("✅ Comparação criada")
         return comparison
         
     except Exception as e:
-        log_message("COMPARE_ERROR", str(e))
+        log_message(f"❌ Erro na comparação: {str(e)}")
         return None
 
+# Importar ImageDraw aqui para evitar erro
+from PIL import ImageDraw
+
 # ========== INTERFACE GRADIO ==========
 
 print("🎨 Criando interface Image Colorizer...")
 
-# CSS customizado
-css = """
-.header-colorizer {
-    text-align: center;
-    padding: 25px;
-    background: linear-gradient(135deg, #ff7e5f 0%, #feb47b 100%);
-    border-radius: 12px;
-    color: white;
-    margin-bottom: 25px;
-    box-shadow: 0 6px 20px rgba(0,0,0,0.1);
-}
-.card-colorizer {
-    padding: 20px;
-    background: white;
-    border-radius: 10px;
-    border: 1px solid #e0e0e0;
-    box-shadow: 0 4px 12px rgba(0,0,0,0.05);
-    margin-bottom: 15px;
-}
-.btn-colorize {
-    background: linear-gradient(135deg, #ff7e5f 0%, #feb47b 100%);
-    color: white;
-    border: none;
-    padding: 16px 32px;
-    border-radius: 10px;
-    font-weight: bold;
-    font-size: 1.2em;
-    transition: all 0.3s;
-    margin: 15px 0;
-}
-.btn-colorize:hover {
-    transform: translateY(-3px);
-    box-shadow: 0 8px 25px rgba(255, 126, 95, 0.4);
-}
-.style-btn {
-    padding: 12px 20px;
-    margin: 5px;
-    border-radius: 8px;
-    border: 2px solid #dee2e6;
-    background: white;
-    transition: all 0.3s;
-    font-weight: 500;
-}
-.style-btn:hover {
-    border-color: #ff7e5f;
-    background: #fff5f2;
-}
-.style-btn.active {
-    border-color: #ff7e5f;
-    background: rgba(255, 126, 95, 0.1);
-    color: #ff7e5f;
-    font-weight: bold;
-}
-.stats-colorizer {
-    padding: 15px;
-    background: linear-gradient(135deg, #fff5f2 0%, #ffe8e0 100%);
-    border-radius: 8px;
-    border-left: 4px solid #ff7e5f;
-    margin: 10px 0;
-}
-.warning-colorizer {
-    padding: 15px;
-    background: #fff3cd;
-    border-radius: 8px;
-    border-left: 4px solid #ffc107;
-    margin: 15px 0;
-}
-.tab-colorizer {
-    padding: 15px;
-    background: #f8f9fa;
-    border-radius: 8px;
-}
-.image-container {
-    border: 2px solid #e0e0e0;
-    border-radius: 8px;
-    padding: 10px;
-    background: white;
-}
-"""
-
-with gr.Blocks(css=css, title="🎨 Image Colorizer - App 5") as demo:
+# Criar interface SEM css no construtor
+with gr.Blocks(title="🎨 Image Colorizer") as demo:
+    
+    # Aplicar CSS depois
+    demo.css = """
+    .header {
+        text-align: center;
+        padding: 20px;
+        background: linear-gradient(135deg, #ff7e5f 0%, #feb47b 100%);
+        border-radius: 10px;
+        color: white;
+        margin-bottom: 20px;
+    }
+    .card {
+        padding: 15px;
+        background: white;
+        border-radius: 8px;
+        border: 1px solid #e0e0e0;
+        margin-bottom: 10px;
+    }
+    .btn-primary {
+        background: linear-gradient(135deg, #ff7e5f 0%, #feb47b 100%);
+        color: white;
+        border: none;
+        padding: 12px 24px;
+        border-radius: 8px;
+        font-weight: bold;
+        margin: 10px 0;
+    }
+    .btn-primary:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(255, 126, 95, 0.3);
+    }
+    .style-btn {
+        padding: 10px 15px;
+        margin: 5px;
+        border-radius: 6px;
+        border: 1px solid #ddd;
+        background: white;
+    }
+    .style-btn:hover {
+        border-color: #ff7e5f;
+        background: #fff5f2;
+    }
+    """
     
     # Cabeçalho
     gr.HTML("""
-    <div class="header-colorizer">
-        <h1 style="margin: 0; font-size: 2.6em;">🎨 Image Colorizer</h1>
-        <p style="margin: 10px 0 0 0; font-size: 1.3em; opacity: 0.95;">App 5 do Photoshop AI Ecosystem</p>
-        <p style="margin: 8px 0 0 0; font-size: 1.1em;">Traga fotos antigas em preto e branco de volta à vida com cores</p>
-        <p style="margin: 15px 0 0 0; font-size: 0.95em; opacity: 0.8;">
-        ✨ Reviva memórias • Adicione cor à história • Transforme instantaneamente
-        </p>
+    <div class="header">
+        <h1 style="margin: 0;">🎨 Image Colorizer</h1>
+        <p style="margin: 5px 0 0 0;">App</p>
+        <p style="margin: 5px 0 0 0; font-size: 0.9em;">Colorize fotos preto e branco automaticamente</p>
     </div>
     """)
     
     with gr.Row():
-        # Coluna esquerda - Upload e configurações
+        # Coluna esquerda
         with gr.Column(scale=1):
-            with gr.Column(elem_classes="card-colorizer"):
+            with gr.Column(elem_classes="card"):
                 gr.Markdown("### 📤 Upload da Foto")
-                gr.Markdown("**Selecione uma foto em preto e branco:**")
                 image_input = gr.Image(
                     type="pil",
-                    label="Arraste ou clique para selecionar",
-                    height=180,
-                    sources=["upload"]
+                    label="Clique ou arraste uma imagem",
+                    height=150
                 )
             
-            with gr.Column(elem_classes="card-colorizer"):
-                gr.Markdown("### 🎨 Estilo de Colorização")
+            with gr.Column(elem_classes="card"):
+                gr.Markdown("### ⚙️ Configurações")
                 
-                gr.Markdown("**Escolha o estilo de cores:**")
+                gr.Markdown("**Estilo de colorização:**")
                 with gr.Row():
                     style_realistic = gr.Button("Realista", elem_classes="style-btn")
                     style_vibrant = gr.Button("Vibrante", elem_classes="style-btn")
@@ -484,65 +357,54 @@ with gr.Blocks(css=css, title="🎨 Image Colorizer - App 5") as demo:
                 intensity_slider = gr.Slider(
                     minimum=0.1,
                     maximum=1.0,
-                    value=0.8,
+                    value=0.7,
                     step=0.1,
                     label="",
-                    info="Controla quão intensas são as cores aplicadas"
+                    info="0.1 = Suave | 1.0 = Intenso"
                 )
             
             colorize_btn = gr.Button(
-                "🎨 Colorizar com IA",
-                elem_classes="btn-colorize",
+                "🎨 Colorizar Imagem",
+                elem_classes="btn-primary",
                 size="lg"
             )
         
-        # Coluna direita - Resultados
+        # Coluna direita
         with gr.Column(scale=1):
-            with gr.Column(elem_classes="card-colorizer"):
-                gr.Markdown("### 📊 Status do Processamento")
+            with gr.Column(elem_classes="card"):
+                gr.Markdown("### 📊 Resultado")
                 status_output = gr.Markdown(
-                    value="**Status:** Aguardando foto em preto e branco...",
-                    elem_classes="stats-colorizer"
+                    value="**Status:** Aguardando imagem...",
+                    elem_classes="card"
                 )
             
-            with gr.Tabs(elem_classes="tab-colorizer"):
+            with gr.Tabs():
                 with gr.TabItem("🔄 Comparação"):
                     comparison_output = gr.Image(
                         type="pil",
-                        label="Comparação lado a lado",
-                        height=280,
-                        elem_classes="image-container"
+                        label="Antes e Depois",
+                        height=300
                     )
                 
-                with gr.TabItem("⚫ Original P&B"):
+                with gr.TabItem("📷 Original"):
                     original_output = gr.Image(
                         type="pil",
-                        label="Foto original em preto e branco",
-                        height=280,
-                        elem_classes="image-container"
+                        label="Original",
+                        height=300
                     )
                 
                 with gr.TabItem("🌈 Colorizada"):
                     colorized_output = gr.Image(
                         type="pil",
-                        label="Foto colorizada com IA",
-                        height=280,
-                        elem_classes="image-container"
+                        label="Colorizada",
+                        height=300
                     )
             
-            with gr.Column(elem_classes="card-colorizer"):
+            with gr.Column(elem_classes="card"):
                 gr.Markdown("### 💾 Download")
                 with gr.Row():
-                    download_colorized = gr.Button(
-                        "📥 Baixar Colorizada",
-                        variant="secondary",
-                        size="lg"
-                    )
-                    download_comparison = gr.Button(
-                        "📊 Baixar Comparação",
-                        variant="secondary",
-                        size="lg"
-                    )
+                    download_colorized = gr.Button("📥 Baixar Colorizada")
+                    download_comparison = gr.Button("📊 Baixar Comparação")
                 
                 download_file = gr.File(
                     label="Arquivo para download",
@@ -550,148 +412,32 @@ with gr.Blocks(css=css, title="🎨 Image Colorizer - App 5") as demo:
                 )
     
     # Informações
-    with gr.Accordion("📖 Guia Completo de Uso", open=False):
-        gr.HTML("""
-        <div class="warning-colorizer">
-        <h4 style="margin: 0 0 10px 0;">💡 Dicas importantes:</h4>
-        <ul style="margin: 0; padding-left: 20px;">
-        <li><strong>Melhores resultados</strong>: Fotos com boa iluminação e contraste</li>
-        <li><strong>Evite</strong>: Fotos muito escuras, borradas ou de baixa qualidade</li>
-        <li><strong>Tamanho ideal</strong>: 500×500px a 1500×1500px</li>
-        <li><strong>Formatos</strong>: JPG, PNG, BMP (RGB ou escala de cinza)</li>
-        </ul>
-        </div>
-        """)
-        
+    with gr.Accordion("📖 Como usar", open=False):
         gr.Markdown("""
-        ## 🚀 Como usar:
-        
-        1. **📤 Carregue** uma foto em preto e branco
-        2. **🎨 Escolha** o estilo de colorização desejado
-        3. **⚙️ Ajuste** a intensidade das cores
-        4. **🚀 Clique** em "Colorizar com IA"
-        5. **👁️ Compare** os resultados nas diferentes abas
-        6. **📥 Baixe** a versão colorizada
-        
-        ## 🎨 Estilos de colorização:
-        
-        ### **Realista** (Recomendado)
-        - Tons naturais de pele
-        - Cores ambientalmente corretas
-        - Ideal para retratos e fotos familiares
-        
-        ### **Vibrante**
-        - Cores intensas e saturadas
-        - Efeito mais artístico
-        - Perfeito para paisagens e natureza
-        
-        ### **Vintage**
-        - Tons sépia e envelhecidos
-        - Estilo retrô e nostálgico
-        - Para fotos antigas e históricas
-        
-        ### **Cinematográfico**
-        - Tons frios e dramáticos
-        - Estilo de filme
-        - Para fotos artísticas
-        
-        ## 📸 Tipos de fotos ideais:
-        
-        ### ✅ Funciona muito bem:
-        - **Retratos** de pessoas
-        - **Fotos familiares** antigas
-        - **Paisagens** em preto e branco
-        - **Eventos históricos**
-        - **Arquitetura** clássica
-        
-        ### ⚠️ Desafios:
-        - Fotos **muito escuras** ou claras
-        - Imagens **borradas** ou de baixa resolução
-        - Fotos com **muitos detalhes** finos
-        - **Textos** ou documentos
-        
-        ## ⚙️ Tecnologia:
-        
-        Este app simula o funcionamento de modelos de IA como **DeOldify**,
-        usando algoritmos que analisam a luminância da imagem e aplicam paletas
-        de cores realistas baseadas em milhões de fotos coloridas.
-        
-        ### Como funciona:
-        1. **Análise**: Detecta regiões (rostos, céu, vegetação, etc.)
-        2. **Referência**: Usa banco de dados de cores realistas
-        3. **Aplicação**: Colora cada pixel de forma contextual
-        4. **Refinamento**: Ajusta cores para naturalidade
-        
-        ## ⏱️ Performance:
-        
-        - **Processamento**: 2-10 segundos (dependendo do tamanho)
-        - **Memória**: < 500MB RAM
-        - **Cache**: Nenhum - processamento sob demanda
-        - **Limite de tamanho**: 4000×4000px (será redimensionado)
-        
-        ## 💡 Dicas avançadas:
-        
-        1. **Para retratos**: Use estilo "Realista" com intensidade 0.7-0.8
-        2. **Para paisagens**: Use "Vibrante" com intensidade 0.8-0.9
-        3. **Para fotos muito antigas**: Use "Vintage" com intensidade 0.6-0.7
-        4. **Se cores parecerem artificiais**: Reduza a intensidade
-        5. **Para mais detalhes**: Use imagens de pelo menos 800px no lado maior
-        
-        ## 🐛 Solução de problemas:
-        
-        ### **"Imagem já colorida"**
-        O app detecta que sua imagem já tem cores. Tente uma foto realmente P&B.
-        
-        ### **"Processamento muito lento"**
-        Imagens muito grandes (>2000px) são redimensionadas automaticamente.
-        
-        ### **"Cores não naturais"**
-        Ajuste o estilo para "Realista" e reduza a intensidade.
-        
-        ### **"Erro ao processar"**
-        Verifique se a imagem é um formato suportado (JPG, PNG, BMP).
-        
-        ## 📊 Resultados esperados:
-        
-        | Tipo de Foto | Realista | Vibrante | Vintage |
-        |--------------|----------|----------|---------|
-        | Retratos     | ⭐⭐⭐⭐⭐ | ⭐⭐⭐☆☆ | ⭐⭐☆☆☆ |
-        | Paisagens    | ⭐⭐⭐⭐☆ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐☆☆ |
-        | Urbanas      | ⭐⭐⭐⭐☆ | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐☆ |
-        | Históricas   | ⭐⭐⭐☆☆ | ⭐⭐☆☆☆ | ⭐⭐⭐⭐⭐ |
+        ## Instruções:
+        1. **Carregue** uma foto em preto e branco
+        2. **Escolha** o estilo de colorização
+        3. **Ajuste** a intensidade das cores
+        4. **Clique** em "Colorizar Imagem"
+        5. **Compare** os resultados
+        6. **Baixe** a imagem colorizada
+        
+        ## Dicas:
+        - **Realista**: Tons naturais para retratos
+        - **Vibrante**: Cores vivas para paisagens
+        - **Vintage**: Estilo antigo e nostálgico
+        - Use intensidade 0.7-0.8 para resultados naturais
         """)
     
     # Rodapé
-    gr.HTML(f"""
-    <div style="
-        text-align: center;
-        margin-top: 30px;
-        padding: 20px;
-        background: linear-gradient(135deg, #fff5f2 0%, #ffe8e0 100%);
-        border-radius: 12px;
-        border-top: 4px solid #ff7e5f;
-        border-bottom: 4px solid #feb47b;
-    ">
-        <p style="margin: 0; font-weight: bold; color: #333; font-size: 1.2em;">
+    gr.HTML("""
+    <div style="text-align: center; margin-top: 20px; padding: 15px; background: #f8f9fa; border-radius: 8px;">
+        <p style="margin: 0; font-weight: bold; color: #333;">
         🎨 Image Colorizer - App 5 do Photoshop AI Ecosystem
         </p>
-        <p style="margin: 10px 0 0 0; color: #666; font-size: 1em;">
-        {MODEL_TYPE} • Python {sys.version.split()[0]} • Gradio {gr.__version__}
-        </p>
-        <p style="margin: 8px 0 0 0; color: #888; font-size: 0.9em;">
-        ⚡ Colorização IA • 🔒 100% Local • ✨ Reviva suas memórias
+        <p style="margin: 5px 0 0 0; color: #666; font-size: 0.9em;">
+        ✨ Cada app tem uma função específica • Este app apenas coloriza imagens
         </p>
-        <div style="margin-top: 15px; display: flex; justify-content: center; gap: 15px; flex-wrap: wrap;">
-            <div style="padding: 8px 15px; background: #ffe8e0; border-radius: 6px;">
-                <span style="font-weight: bold; color: #ff5722;">🎯 Estilos:</span> Realista • Vibrante • Vintage
-            </div>
-            <div style="padding: 8px 15px; background: #e3f2fd; border-radius: 6px;">
-                <span style="font-weight: bold; color: #1976d2;">⚡ Processamento:</span> 2-10s
-            </div>
-            <div style="padding: 8px 15px; background: #e8f5e9; border-radius: 6px;">
-                <span style="font-weight: bold; color: #388e3c;">🔒 Privacidade:</span> 100% Local
-            </div>
-        </div>
     </div>
     """)
     
@@ -713,47 +459,40 @@ with gr.Blocks(css=css, title="🎨 Image Colorizer - App 5") as demo:
     
     # Processar imagem
     def process_colorization(image, style, intensity):
-        log_message("PROCESS", f"Iniciando colorização - Estilo: {style}, Intensidade: {intensity}")
+        log_message(f"Processando - Estilo: {style}, Intensidade: {intensity}")
         
         if image is None:
-            return None, None, None, "❌ **Erro:** Nenhuma imagem carregada"
+            return None, None, None, "❌ Por favor, carregue uma imagem primeiro"
         
-        original, colorized, result = colorize_image(image, style, intensity)
+        # Validar imagem
+        valid_img, msg = validate_image(image)
+        if valid_img is None:
+            return None, None, None, f"❌ {msg}"
+        
+        # Redimensionar se necessário
+        if max(valid_img.size) > MAX_IMAGE_SIZE:
+            valid_img = resize_image(valid_img, MAX_IMAGE_SIZE)
         
-        if colorized is None:
-            return None, None, None, f"❌ **Erro:** {result}"
+        # Aplicar colorização
+        colorized = apply_colorization(valid_img, style, intensity)
         
         # Criar comparação
-        comparison = create_comparison(original, colorized)
+        comparison = create_comparison(valid_img, colorized)
         
-        # Criar mensagem de status
-        if isinstance(result, dict):
-            status_msg = f"""
-            ✅ **Colorização concluída com sucesso!**
-            
-            📊 **Estatísticas:**
-            • Tamanho: {result['original_size']}
-            • Estilo aplicado: {result['style'].title()}
-            • Intensidade: {result['intensity']}
-            • Modelo: {result['model']}
-            
-            🎨 **Resultado:**
-            Sua foto foi colorizada com tons {result['style']} em {result['intensity']} de intensidade.
-            
-            💡 **Dica:** Use as abas acima para comparar antes e depois.
-            """
-        else:
-            status_msg = f"""
-            ✅ **Colorização aplicada!**
-            
-            Tamanho original: {original.size[0]}×{original.size[1]}px
-            Estilo: {style.title()}
-            Intensidade: {intensity*100:.0f}%
-            
-            💡 **Compare** os resultados na aba "Comparação".
-            """
+        # Mensagem de status
+        status = f"""
+        ✅ **Colorização aplicada com sucesso!**
+        
+        **Detalhes:**
+        • Estilo: {style.title()}
+        • Intensidade: {intensity*100:.0f}%
+        • Tamanho original: {valid_img.size[0]}×{valid_img.size[1]}px
+        • Tamanho colorizado: {colorized.size[0]}×{colorized.size[1]}px
         
-        return original, colorized, comparison, status_msg
+        **Próximo passo:** Veja os resultados nas abas acima ou faça download.
+        """
+        
+        return valid_img, colorized, comparison, status
     
     colorize_btn.click(
         fn=process_colorization,
@@ -763,13 +502,13 @@ with gr.Blocks(css=css, title="🎨 Image Colorizer - App 5") as demo:
     
     # Downloads
     download_colorized.click(
-        fn=save_colorized_image,
+        fn=save_image,
         inputs=[colorized_output],
         outputs=[download_file]
     )
     
     download_comparison.click(
-        fn=save_colorized_image,
+        fn=save_image,
         inputs=[comparison_output],
         outputs=[download_file]
     )
@@ -777,41 +516,26 @@ with gr.Blocks(css=css, title="🎨 Image Colorizer - App 5") as demo:
     # Limpar ao carregar nova imagem
     def clear_on_upload(image):
         if image is None:
-            return None, None, None, "**Status:** Aguardando foto em preto e branco..."
+            return None, None, None, "**Status:** Aguardando imagem..."
         
-        valid_img, status = validate_image(image)
+        valid_img, msg = validate_image(image)
         if valid_img is None:
-            return None, None, None, f"❌ {status}"
+            return None, None, None, f"❌ {msg}"
         
-        # Verificar se já é colorida
-        if status == "color":
-            msg = """
-            ⚠️ **Atenção:** Esta imagem já parece ter cores.
-            
-            O Image Colorizer funciona melhor com fotos verdadeiramente em preto e branco.
-            Você ainda pode processá-la, mas os resultados podem ser diferentes.
-            
-            **Dica:** Para melhores resultados, use fotos em escala de cinza.
-            """
-        else:
-            size_info = f"{valid_img.size[0]}×{valid_img.size[1]}px"
-            msg = f"""
-            ✅ **Foto em preto e branco carregada!**
-            
-            📏 **Detalhes:**
-            • Tamanho: {size_info}
-            • Formato: {valid_img.mode}
-            • Pronto para colorização
-            
-            **Próximos passos:**
-            1. Escolha um estilo de colorização
-            2. Ajuste a intensidade das cores
-            3. Clique em "Colorizar com IA"
-            
-            🎯 **Dica:** Use "Realista" para fotos de pessoas e "Vibrante" para paisagens.
-            """
+        status = f"""
+        ✅ **Imagem carregada com sucesso!**
         
-        return None, None, None, msg
+        **Detalhes:**
+        • Tamanho: {valid_img.size[0]}×{valid_img.size[1]}px
+        • Formato: {valid_img.mode}
+        
+        **Próximos passos:**
+        1. Escolha um estilo de colorização
+        2. Ajuste a intensidade das cores
+        3. Clique em "Colorizar Imagem"
+        """
+        
+        return None, None, None, status
     
     image_input.change(
         fn=clear_on_upload,
@@ -822,13 +546,7 @@ with gr.Blocks(css=css, title="🎨 Image Colorizer - App 5") as demo:
 print("=" * 60)
 print("✅ APP 5: IMAGE COLORIZER PRONTO!")
 print("=" * 60)
-print("📦 Esta versão é LEVE e FUNCIONAL:")
-print("   • Sem dependências pesadas (torch/fastai)")
-print("   • Algoritmo de colorização simulado eficiente")
-print("   • Processamento rápido (< 10s)")
-print("   • Múltiplos estilos de colorização")
-print("=" * 60)
-print("🚀 Pronto para deploy no Hugging Face Spaces!")
+print("📦 Versão simplificada e funcional")
 print("=" * 60)
 
 # O Hugging Face Spaces cuida do demo.launch()