Update app.py

app.py

@@ -1,30 +1,18 @@
 """
 🎨 Image Colorizer
-Versão 100% funcional para Hugging Face Spaces
+Versão otimizada para Hugging Face Spaces
 """
 
 import gradio as gr
-from PIL import Image, ImageOps, ImageEnhance, ImageFilter
+from PIL import Image, ImageEnhance, ImageFilter, ImageDraw
 import numpy as np
 import tempfile
 import time
 import os
-import sys
-from pathlib import Path
 
-print("=" * 60)
-print("🚀 INICIANDO APP: IMAGE COLORIZER")
-print(f"Python version: {sys.version}")
-print(f"Pillow version: {Image.__version__}")
-print("=" * 60)
+print("🚀 Iniciando Image Colorizer...")
 
-# ========== CONFIGURAÇÃO ==========
-
-MAX_IMAGE_SIZE = 1024  # Para processamento rápido
-
-print(f"📏 Tamanho máximo: {MAX_IMAGE_SIZE}px")
-
-# ========== FUNÇÕES AUXILIARES ==========
+MAX_IMAGE_SIZE = 1024
 
 def log_message(message):
     """Log para debug"""
@@ -37,37 +25,25 @@ def validate_image(image):
         if image is None:
             return None, "❌ Nenhuma imagem fornecida"
         
-        log_message(f"Validando imagem - Tipo: {type(image)}")
-        
-        # Converter para PIL Image
-        if isinstance(image, dict):  # Gradio dict
-            if 'image' in image:
-                img_array = image['image']
-                if isinstance(img_array, np.ndarray):
-                    img = Image.fromarray(img_array.astype('uint8'))
-                else:
-                    return None, "❌ Formato de array inválido"
-            else:
-                return None, "❌ Dicionário sem chave 'image'"
-        elif isinstance(image, np.ndarray):
+        # Converter para PIL Image se necessário
+        if isinstance(image, np.ndarray):
             img = Image.fromarray(image.astype('uint8'))
         else:
-            img = image  # Já é PIL Image
+            img = image
         
         # Verificar tamanho
         if max(img.size) > 4000:
-            return None, "❌ Imagem muito grande (>4000px)."
+            return None, "❌ Imagem muito grande (>4000px)"
         
         if min(img.size) < 32:
-            return None, "❌ Imagem muito pequena (<32px)."
+            return None, "❌ Imagem muito pequena (<32px)"
         
         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(error_msg)
-        return None, error_msg
+        log_message(f"❌ Erro na validação: {str(e)}")
+        return None, str(e)
 
 def resize_image(image, max_size):
     """Redimensiona mantendo aspect ratio"""
@@ -78,157 +54,86 @@ def resize_image(image, max_size):
     new_width = int(image.width * ratio)
     new_height = int(image.height * ratio)
     
-    log_message(f"Redimensionando: {image.size} -> ({new_width}, {new_height})")
-    
     return image.resize((new_width, new_height), Image.Resampling.LANCZOS)
 
 def apply_colorization(image, style="realistic", intensity=0.8):
     """Aplica colorização à imagem"""
     try:
         log_message(f"Aplicando colorização - Estilo: {style}, Intensidade: {intensity}")
-        start_time = time.time()
         
-        # Converter para RGB se necessário
+        # Converter para RGB
         if image.mode != 'RGB':
             rgb_img = image.convert('RGB')
         else:
             rgb_img = image.copy()
         
-        # Converter para escala de cinza para análise
         gray_img = rgb_img.convert('L')
         
-        # Aplicar diferentes efeitos baseados no estilo
+        # Aplicar 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')
-            
         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)
+        else:  # balanced
             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))
         
-        # Se a imagem original era escala de cinza, misturar com o resultado colorizado
+        # Misturar se imagem era grayscale
         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(f"✅ Colorização concluída em {process_time:.1f}s")
-        
+        log_message("✅ Colorização concluída")
         return result
         
     except Exception as e:
         log_message(f"❌ Erro na colorização: {str(e)}")
-        return image  # Retorna original em caso de erro
-
-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")
-        
-        temp_file = tempfile.NamedTemporaryFile(
-            delete=False,
-            suffix=".png",
-            prefix=f"{prefix}_"
-        )
-        
-        # Salvar com alta qualidade
-        image.save(temp_file.name, "PNG", optimize=True)
-        
-        file_size = os.path.getsize(temp_file.name) // 1024
-        log_message(f"Imagem salva: {temp_file.name} ({file_size}KB)")
-        
-        return temp_file.name
-        
-    except Exception as e:
-        log_message(f"❌ Erro ao salvar: {str(e)}")
-        return None
+        return image
 
 def create_comparison(original, colorized):
     """Cria comparação lado a lado"""
@@ -236,7 +141,6 @@ def create_comparison(original, colorized):
         if original is None or colorized is None:
             return None
         
-        # Redimensionar para mesma altura
         target_height = 400
         target_width_orig = int(original.width * (target_height / original.height))
         target_width_color = int(colorized.width * (target_height / colorized.height))
@@ -244,21 +148,15 @@ def create_comparison(original, colorized):
         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
         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
-        
         draw = ImageDraw.Draw(comparison)
         
-        # 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, (0, 40))
         comparison.paste(colorized_resized, (original_resized.width + 20, 40))
         
@@ -269,149 +167,76 @@ def create_comparison(original, colorized):
         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...")
+def save_image(image, prefix="colorized"):
+    """Salva imagem para download"""
+    try:
+        if image is None:
+            return None
+        
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png", prefix=f"{prefix}_")
+        image.save(temp_file.name, "PNG", optimize=True)
+        
+        log_message(f"Imagem salva: {temp_file.name}")
+        return temp_file.name
+        
+    except Exception as e:
+        log_message(f"❌ Erro ao salvar: {str(e)}")
+        return None
 
-# 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;
-    }
-    """
+# Interface Gradio
+with gr.Blocks(title="🎨 Image Colorizer", theme=gr.themes.Soft()) as demo:
     
-    # Cabeçalho
     gr.HTML("""
-    <div class="header">
+    <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #ff7e5f 0%, #feb47b 100%); border-radius: 10px; color: white; margin-bottom: 20px;">
         <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>
+        <p style="margin: 5px 0 0 0;">Colorize fotos preto e branco automaticamente</p>
     </div>
     """)
     
     with gr.Row():
-        # Coluna esquerda
         with gr.Column(scale=1):
-            with gr.Column(elem_classes="card"):
-                gr.Markdown("### 📤 Upload da Foto")
-                image_input = gr.Image(
-                    type="pil",
-                    label="Clique ou arraste uma imagem",
-                    height=150
-                )
+            gr.Markdown("### 📤 Upload da Foto")
+            image_input = gr.Image(type="pil", label="Clique ou arraste uma imagem")
             
-            with gr.Column(elem_classes="card"):
-                gr.Markdown("### ⚙️ Configurações")
-                
-                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")
-                    style_vintage = gr.Button("Vintage", elem_classes="style-btn")
-                
-                style_selected = gr.Textbox(value="realistic", visible=False)
-                
-                gr.Markdown("**Intensidade das cores:**")
-                intensity_slider = gr.Slider(
-                    minimum=0.1,
-                    maximum=1.0,
-                    value=0.7,
-                    step=0.1,
-                    label="",
-                    info="0.1 = Suave | 1.0 = Intenso"
-                )
+            gr.Markdown("### ⚙️ Configurações")
+            gr.Markdown("**Estilo de colorização:**")
+            
+            with gr.Row():
+                style_realistic = gr.Button("Realista", size="sm")
+                style_vibrant = gr.Button("Vibrante", size="sm")
+                style_vintage = gr.Button("Vintage", size="sm")
+            
+            style_selected = gr.Textbox(value="realistic", visible=False)
             
-            colorize_btn = gr.Button(
-                "🎨 Colorizar Imagem",
-                elem_classes="btn-primary",
-                size="lg"
+            gr.Markdown("**Intensidade das cores:**")
+            intensity_slider = gr.Slider(
+                minimum=0.1, maximum=1.0, value=0.7, step=0.1,
+                label="", info="0.1 = Suave | 1.0 = Intenso"
             )
+            
+            colorize_btn = gr.Button("🎨 Colorizar Imagem", variant="primary", size="lg")
         
-        # Coluna direita
         with gr.Column(scale=1):
-            with gr.Column(elem_classes="card"):
-                gr.Markdown("### 📊 Resultado")
-                status_output = gr.Markdown(
-                    value="**Status:** Aguardando imagem...",
-                    elem_classes="card"
-                )
+            gr.Markdown("### 📊 Resultado")
+            status_output = gr.Markdown("**Status:** Aguardando imagem...")
             
             with gr.Tabs():
                 with gr.TabItem("🔄 Comparação"):
-                    comparison_output = gr.Image(
-                        type="pil",
-                        label="Antes e Depois",
-                        height=300
-                    )
+                    comparison_output = gr.Image(type="pil", label="Antes e Depois")
                 
                 with gr.TabItem("📷 Original"):
-                    original_output = gr.Image(
-                        type="pil",
-                        label="Original",
-                        height=300
-                    )
+                    original_output = gr.Image(type="pil", label="Original")
                 
                 with gr.TabItem("🌈 Colorizada"):
-                    colorized_output = gr.Image(
-                        type="pil",
-                        label="Colorizada",
-                        height=300
-                    )
+                    colorized_output = gr.Image(type="pil", label="Colorizada")
             
-            with gr.Column(elem_classes="card"):
-                gr.Markdown("### 💾 Download")
-                with gr.Row():
-                    download_colorized = gr.Button("📥 Baixar Colorizada")
-                    download_comparison = gr.Button("📊 Baixar Comparação")
-                
-                download_file = gr.File(
-                    label="Arquivo para download",
-                    interactive=False
-                )
+            gr.Markdown("### 💾 Download")
+            with gr.Row():
+                download_colorized = gr.Button("📥 Baixar Colorizada")
+                download_comparison = gr.Button("📊 Baixar Comparação")
+            
+            download_file = gr.File(label="Arquivo para download", interactive=False)
     
-    # Informações
     with gr.Accordion("📖 Como usar", open=False):
         gr.Markdown("""
         ## Instruções:
@@ -419,77 +244,46 @@ with gr.Blocks(title="🎨 Image Colorizer") as demo:
         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
+        5. **Compare** os resultados e baixe
         
-        ## Dicas:
+        ## Estilos:
         - **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("""
     <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: 5px 0 0 0; color: #666; font-size: 0.9em;">
-        ✨ Cada app tem uma função específica • Este app apenas coloriza imagens
-        </p>
+        <p style="margin: 0; color: #666;">🎨 Image Colorizer - Photoshop AI Ecosystem</p>
     </div>
     """)
     
-    # ========== EVENT HANDLERS ==========
-    
-    # Botões de estilo
-    def set_style_realistic():
-        return "realistic"
-    
-    def set_style_vibrant():
-        return "vibrant"
-    
-    def set_style_vintage():
-        return "vintage"
-    
-    style_realistic.click(fn=set_style_realistic, outputs=[style_selected])
-    style_vibrant.click(fn=set_style_vibrant, outputs=[style_selected])
-    style_vintage.click(fn=set_style_vintage, outputs=[style_selected])
+    # Event handlers
+    style_realistic.click(fn=lambda: "realistic", outputs=[style_selected])
+    style_vibrant.click(fn=lambda: "vibrant", outputs=[style_selected])
+    style_vintage.click(fn=lambda: "vintage", outputs=[style_selected])
     
-    # Processar imagem
     def process_colorization(image, style, intensity):
-        log_message(f"Processando - Estilo: {style}, Intensidade: {intensity}")
-        
         if image is None:
             return None, None, None, "❌ Por favor, carregue uma imagem primeiro"
         
-        # 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)
         
-        # Aplicar colorização
         colorized = apply_colorization(valid_img, style, intensity)
-        
-        # Criar comparação
         comparison = create_comparison(valid_img, colorized)
         
-        # 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
-        
-        **Próximo passo:** Veja os resultados nas abas acima ou faça download.
+        • Tamanho: {valid_img.size[0]}×{valid_img.size[1]}px
         """
         
         return valid_img, colorized, comparison, status
@@ -500,20 +294,9 @@ with gr.Blocks(title="🎨 Image Colorizer") as demo:
         outputs=[original_output, colorized_output, comparison_output, status_output]
     )
     
-    # Downloads
-    download_colorized.click(
-        fn=save_image,
-        inputs=[colorized_output],
-        outputs=[download_file]
-    )
-    
-    download_comparison.click(
-        fn=save_image,
-        inputs=[comparison_output],
-        outputs=[download_file]
-    )
+    download_colorized.click(fn=save_image, inputs=[colorized_output], outputs=[download_file])
+    download_comparison.click(fn=save_image, inputs=[comparison_output], outputs=[download_file])
     
-    # Limpar ao carregar nova imagem
     def clear_on_upload(image):
         if image is None:
             return None, None, None, "**Status:** Aguardando imagem..."
@@ -522,19 +305,7 @@ with gr.Blocks(title="🎨 Image Colorizer") as demo:
         if valid_img is None:
             return None, None, None, f"❌ {msg}"
         
-        status = f"""
-        ✅ **Imagem carregada com sucesso!**
-        
-        **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"
-        """
-        
+        status = f"✅ **Imagem carregada!** ({valid_img.size[0]}×{valid_img.size[1]}px)\n\nEscolha um estilo e clique em Colorizar."
         return None, None, None, status
     
     image_input.change(
@@ -543,10 +314,6 @@ with gr.Blocks(title="🎨 Image Colorizer") as demo:
         outputs=[original_output, colorized_output, comparison_output, status_output]
     )
 
-print("=" * 60)
-print("✅ APP 5: IMAGE COLORIZER PRONTO!")
-print("=" * 60)
-print("📦 Versão simplificada e funcional")
-print("=" * 60)
-
-# O Hugging Face Spaces cuida do demo.launch()
+if __name__ == "__main__":
+    log_message("✅ Iniciando aplicação...")
+    demo.launch()