Update app.py

app.py

@@ -1,92 +1,149 @@
-import gradio as gr
-import trimesh
-from instant_texture import Converter
 import os
-import uuid
-from PIL import Image
+import sys
+import logging
 
-# Inicializa o conversor
-converter = Converter()
-
-def extract_texture(mesh_path: str):
-    """Tenta extrair a textura base do arquivo GLB gerado."""
+# -----------------------------------------------------------------------------
+# SEÇÃO 1: COMPATIBILIDADE DE SISTEMA (Polyfill para Python 3.13+)
+# -----------------------------------------------------------------------------
+# O Python 3.13 removeu o módulo 'audioop'. O Gradio e Pydub dependem dele.
+# Este bloco tenta importar o substituto 'audioop-lts' e injetá-lo como 'audioop'.
+try:
+    import audioop
+except ImportError:
     try:
-        # Carrega a cena GLB
-        scene = trimesh.load(mesh_path)
-        
-        # GLBs são carregados como 'Scenes'. Precisamos pegar a primeira malha (geometry) da cena.
-        # Se a cena estiver vazia, isso vai gerar um erro que o 'except' pega.
-        if not scene.geometry:
-             print("Erro: Nenhuma geometria encontrada no GLB gerado.")
-             return None
-             
-        mesh = next(iter(scene.geometry.values()))
+        import audioop_lts as audioop
+        sys.modules["audioop"] = audioop
+        print("Módulo 'audioop-lts' carregado com sucesso para compatibilidade Python 3.13.")
+    except ImportError:
+        print("AVISO CRÍTICO: 'audioop' não encontrado. Recursos de áudio falharão em Python 3.13+.")
 
-        # Verifica se a malha tem material e se o material tem a textura de cor base
-        if hasattr(mesh.visual, 'material') and hasattr(mesh.visual.material, 'baseColorTexture'):
-            texture = mesh.visual.material.baseColorTexture
-            # Verifica se a textura é uma imagem PIL válida antes de retornar
-            if isinstance(texture, Image.Image):
-                return texture
-        
-        print("Aviso: O modelo GLB foi gerado, mas nenhuma textura baseColorTexture foi encontrada.")
-        return None
+# -----------------------------------------------------------------------------
+# SEÇÃO 2: IMPORTAÇÕES E CONFIGURAÇÃO DE AMBIENTE
+# -----------------------------------------------------------------------------
+import gradio as gr
+import spaces  # Biblioteca essencial para gerenciamento de GPU em HF Spaces
+import torch
+from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, UniPCMultistepScheduler
+from PIL import Image
 
-    except Exception as e:
-        print(f"Erro ao extrair textura: {e}")
-        return None
+# Configuração de Logs para diagnóstico facilitado
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-def convert(input_mesh_path: str):
-    # Validação de entrada
-    if input_mesh_path is None:
-        raise gr.Error("Por favor, envie um arquivo .obj.")
-        
-    if not input_mesh_path.endswith(".obj"):
-        raise gr.Error("Apenas arquivos .obj são suportados.")
+logger.info(f"Python Version: {sys.version}")
+logger.info(f"Gradio Version: {gr.__version__}")
+logger.info(f"Pydantic Version: {sys.modules.get('pydantic', 'Not Loaded')}")
+logger.info(f"CUDA Available: {torch.cuda.is_available()}")
 
-    # --- MUDANÇA CRÍTICA 1: Arquivos Temporários Únicos ---
-    # Em um Space, múltiplos usuários podem usar o app ao mesmo tempo.
-    # Usar sempre "/tmp/output.glb" faria um usuário sobrescrever o arquivo do outro.
-    # Usamos UUID para criar um nome de arquivo único para cada execução.
-    unique_filename = str(uuid.uuid4())
-    output_path = os.path.join("/tmp", f"output_{unique_filename}.glb")
+# -----------------------------------------------------------------------------
+# SEÇÃO 3: CARREGAMENTO DO MODELO (Cache Global)
+# -----------------------------------------------------------------------------
+# Carregar modelos fora da função de inferência para evitar recarregamento a cada requisição.
+# Utiliza variáveis de ambiente ou IDs padrão.
 
-    try:
-        # Executa a conversão (assumindo que esta biblioteca funciona corretamente)
-        converter.convert(input_mesh_path, output_path)
+MODEL_ID = "runwayml/stable-diffusion-v1-5"
+CONTROLNET_ID = "lllyasviel/sd-controlnet-canny"
+
+try:
+    if torch.cuda.is_available():
+        logger.info("Inicializando modelos na GPU...")
+        controlnet = ControlNetModel.from_pretrained(CONTROLNET_ID, torch_dtype=torch.float16)
+        pipe = StableDiffusionControlNetPipeline.from_pretrained(
+            MODEL_ID, controlnet=controlnet, torch_dtype=torch.float16
+        )
+        pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+        pipe.to("cuda")
+        pipe.enable_model_cpu_offload() # Otimização para Spaces com VRAM limitada
+    else:
+        logger.warning("GPU não detectada. O modelo rodará em CPU (extremamente lento).")
+        controlnet = ControlNetModel.from_pretrained(CONTROLNET_ID)
+        pipe = StableDiffusionControlNetPipeline.from_pretrained(MODEL_ID, controlnet=controlnet)
+except Exception as e:
+    logger.error(f"Erro fatal ao carregar modelos: {e}")
+    # Não interrompemos o script aqui para permitir que a UI carregue e mostre o erro, se necessário
+
+# -----------------------------------------------------------------------------
+# SEÇÃO 4: LÓGICA DE INFERÊNCIA COM DECORADOR ZERO-GPU
+# -----------------------------------------------------------------------------
 
-        # Verifica se o arquivo de saída foi realmente criado
-        if not os.path.exists(output_path):
-             raise gr.Error("Falha na conversão: O arquivo de saída não foi gerado.")
+@spaces.GPU(duration=120) # Aloca a GPU para esta função por até 120 segundos
+def process_image(input_image, prompt, negative_prompt, num_steps, guidance_scale):
+    """
+    Função principal de geração. O decorador @spaces.GPU gerencia a fila e a alocação
+    de hardware automaticamente nos Hugging Face Spaces.
+    """
+    if input_image is None:
+        raise gr.Error("Por favor, forneça uma imagem de entrada.")
+    
+    if not torch.cuda.is_available():
+        raise gr.Error("GPU não disponível neste ambiente. Impossível gerar imagem.")
 
-        # Extrai a textura do novo arquivo GLB
-        texture = extract_texture(output_path)
+    try:
+        # Pre-processamento Canny (Exemplo para ControlNet Canny)
+        import cv2
+        import numpy as np
         
-        if texture is None:
-             # Se não conseguiu extrair a textura, retorna o modelo, mas avisa no log
-             print("Retornando modelo sem imagem de textura separada.")
-             return output_path, None
+        image = np.array(input_image)
+        low_threshold = 100
+        high_threshold = 200
+        image = cv2.Canny(image, low_threshold, high_threshold)
+        image = image[:, :, None]
+        image = np.concatenate([image, image, image], axis=2)
+        canny_image = Image.fromarray(image)
 
-        return output_path, texture
+        # Inferência
+        output = pipe(
+            prompt,
+            image=canny_image,
+            negative_prompt=negative_prompt,
+            num_inference_steps=int(num_steps),
+            guidance_scale=guidance_scale
+        ).images
         
+        return output
     except Exception as e:
-        # Captura erros da biblioteca instant_texture e mostra pro usuário
-        raise gr.Error(f"Erro durante o processo de conversão: {str(e)}")
+        logger.error(f"Erro durante a inferência: {e}")
+        raise gr.Error(f"Falha na geração: {str(e)}")
+
+# -----------------------------------------------------------------------------
+# SEÇÃO 5: CONSTRUÇÃO DA INTERFACE (Gradio Blocks)
+# -----------------------------------------------------------------------------
+
+with gr.Blocks(title="ControlNet Stable Diffusion", theme=gr.themes.Base()) as demo:
+    gr.Markdown("# 🎨 Stable Diffusion com ControlNet (Canny)")
+    gr.Markdown("Gere variações artísticas baseadas na estrutura de uma imagem de entrada.")
+    
+    with gr.Row():
+        with gr.Column():
+            input_img = gr.Image(label="Imagem de Referência", type="pil", sources=["upload", "webcam"])
+            prompt_txt = gr.Textbox(label="Prompt Positivo", value="cyberpunk city, neon lights, highly detailed", lines=2)
+            neg_prompt_txt = gr.Textbox(label="Prompt Negativo", value="low quality, blurred, ugly, disfigured", lines=2)
+            
+            with gr.Accordion("Configurações Avançadas", open=False):
+                steps_slider = gr.Slider(label="Passos de Inferência", minimum=10, maximum=50, value=25, step=1)
+                cfg_slider = gr.Slider(label="Guidance Scale", minimum=1.0, maximum=20.0, value=7.5, step=0.5)
+            
+            generate_btn = gr.Button("Gerar Imagem", variant="primary", size="lg")
+        
+        with gr.Column():
+            output_img = gr.Image(label="Resultado Gerado", interactive=False)
 
-# Configuração da Interface Gradio
-demo = gr.Interface(
-    fn=convert,
-    title="Instant Texture",
-    description="Convert a vertex-colored mesh (.obj) to a uv-mapped, textured mesh (.glb).",
-    inputs=gr.Model3D(label="Vertex-colored mesh (.obj)"),
-    outputs=[
-        gr.Model3D(label="Output uv-mapped, textured mesh (.glb)"),
-        gr.Image(label="Output texture", type="pil"), # Força o tipo PIL para garantir compatibilidade
-    ],
-    # Verifique se o caminho do exemplo está correto no seu repositório
-    # examples=[["examples/chair.obj"]], 
-    cache_examples=False, # Desativado temporariamente para evitar erros se o exemplo não existir
-)
+    # Conexão de Eventos
+    generate_btn.click(
+        fn=process_image,
+        inputs=[input_img, prompt_txt, neg_prompt_txt, steps_slider, cfg_slider],
+        outputs=output_img
+    )
 
+# -----------------------------------------------------------------------------
+# SEÇÃO 6: LANÇAMENTO DO SERVIDOR
+# -----------------------------------------------------------------------------
 if __name__ == "__main__":
-    demo.queue().launch()
+    # share=False é CRUCIAL. share=True tenta criar túneis SSH que falham em Spaces e
+    # geram o erro "ValueError: When localhost is not accessible".
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        share=False,
+        allowed_paths=["."]
+    )