Update app.py

app.py

@@ -2,79 +2,57 @@ import os
 import shlex
 import spaces
 import subprocess
-import argparse
 import uuid
-import random
+import torch
+import trimesh
+import argparse
 import numpy as np
+import gradio as gr
+import random
 
 # --------------------------------------------------------------------------
-# BLOQUE 1: INSTALACIÓN DEL ENTORNO Y DEPENDENCIAS
-# Esta sección DEBE ejecutarse en su totalidad ANTES de importar torch o gradio.
+# 1. INSTALACIÓN DEL ENTORNO Y DEPENDENCIAS (Sin cambios)
 # --------------------------------------------------------------------------
-
 @spaces.GPU(duration=120)
 def setup_environment():
-    """
-    Prepara todo el entorno necesario, instalando CUDA y compilando las extensiones.
-    Esta función se ejecuta una vez al inicio del Space.
-    """
+    """Prepara el entorno, instalando CUDA y compilando extensiones."""
     print("--- INICIANDO CONFIGURACIÓN DEL ENTORNO ---")
-
-    # 1. Instalar CUDA Toolkit
     if not os.path.exists("/usr/local/cuda"):
         print("Instalando CUDA Toolkit...")
         CUDA_TOOLKIT_URL = "https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda_12.4.0_550.54.14_linux.run"
         CUDA_TOOLKIT_FILE = f"/tmp/{os.path.basename(CUDA_TOOLKIT_URL)}"
-        
         subprocess.run(["wget", "-q", CUDA_TOOLKIT_URL, "-O", CUDA_TOOLKIT_FILE], check=True)
         subprocess.run(["chmod", "+x", CUDA_TOOLKIT_FILE], check=True)
-        # Se añade --override para evitar problemas en algunos entornos de HF Spaces
         subprocess.run([CUDA_TOOLKIT_FILE, "--silent", "--toolkit", "--override"], check=True)
-        print("CUDA Toolkit instalado.")
     else:
         print("CUDA Toolkit ya está instalado.")
-
-    # 2. Configurar variables de entorno
+    
     os.environ["CUDA_HOME"] = "/usr/local/cuda"
     os.environ["PATH"] = f"{os.environ['CUDA_HOME']}/bin:{os.environ['PATH']}"
-    # La ruta correcta en la mayoría de las distribuciones de Linux es lib64
     os.environ["LD_LIBRARY_PATH"] = f"{os.environ['CUDA_HOME']}/lib64:{os.environ.get('LD_LIBRARY_PATH', '')}"
     os.environ["TORCH_CUDA_ARCH_LIST"] = "8.0;8.6"
     print("Variables de entorno de CUDA configuradas.")
-
-    # 3. Verificar NVCC
-    print("Verificando versión de NVCC:")
     os.system('nvcc -V')
 
-    # 4. Compilar extensiones C++/CUDA
     print("Compilando extensión de renderizador diferenciable...")
     try:
-        subprocess.run(
-            "cd /home/user/app/step1x3d_texture/differentiable_renderer/ && python setup.py install", 
-            shell=True, check=True, capture_output=True, text=True
-        )
-        print("Renderizador diferenciable compilado.")
+        subprocess.run("cd /home/user/app/step1x3d_texture/differentiable_renderer/ && python setup.py install", shell=True, check=True)
     except subprocess.CalledProcessError as e:
-        print(f"ERROR al compilar el renderizador diferenciable:\n{e.stderr}")
+        print(f"ERROR al compilar el renderizador diferenciable: {e}")
         raise RuntimeError("Fallo crítico en la compilación del renderizador.")
 
     print("Instalando rasterizador personalizado...")
     try:
         subprocess.run(shlex.split("pip install custom_rasterizer-0.1-cp310-cp310-linux_x86_64.whl"), check=True)
-        print("Rasterizador personalizado instalado.")
     except Exception as e:
         print(f"ERROR al instalar el rasterizador personalizado: {e}")
         raise RuntimeError("Fallo crítico en la instalación del rasterizador.")
-
     print("--- CONFIGURACIÓN DEL ENTORNO FINALIZADA ---")
 
-# Ejecutar la configuración del entorno antes de cualquier otra cosa
 setup_environment()
 
-
 # --------------------------------------------------------------------------
-# BLOQUE 2: IMPORTACIONES DE LA APLICACIÓN Y LÓGICA PRINCIPAL
-# Todas las importaciones que dependen de CUDA se hacen AHORA.
+# 2. IMPORTACIONES Y CARGA DE MODELOS (Después de la configuración)
 # --------------------------------------------------------------------------
 import torch
 import trimesh
@@ -82,9 +60,6 @@ import gradio as gr
 from step1x3d_texture.pipelines.step1x_3d_texture_synthesis_pipeline import Step1X3DTexturePipeline
 from step1x3d_geometry.models.pipelines.pipeline_utils import reduce_face, remove_degenerate_face
 
-# --------------------------------------------------------------------------
-# 3. CONFIGURACIÓN Y CARGA DEL MODELO DE TEXTURA
-# --------------------------------------------------------------------------
 parser = argparse.ArgumentParser()
 parser.add_argument("--texture_model", type=str, default="Step1X-3D-Texture")
 parser.add_argument("--cache_dir", type=str, default="cache")
@@ -94,7 +69,6 @@ os.makedirs(args.cache_dir, exist_ok=True)
 device = "cuda" if torch.cuda.is_available() else "cpu"
 MAX_SEED = np.iinfo(np.int32).max
 
-print(f"Dispositivo detectado: {device}")
 if not torch.cuda.is_available():
     raise RuntimeError("CUDA no está disponible para PyTorch. La aplicación no puede continuar.")
 
@@ -102,30 +76,32 @@ print(f"Cargando modelo de textura: {args.texture_model}...")
 texture_model = Step1X3DTexturePipeline.from_pretrained("stepfun-ai/Step1X-3D", subfolder=args.texture_model)
 print("Modelo de textura cargado y listo.")
 
-
 # --------------------------------------------------------------------------
-# 4. FUNCIÓN DE GENERACIÓN DE TEXTURA
+# 3. FUNCIONES DE LÓGICA
 # --------------------------------------------------------------------------
 
 def get_random_seed(randomize_seed, seed):
-    """Genera una semilla aleatoria si se solicita."""
+    """Devuelve una semilla aleatoria si la casilla está marcada, de lo contrario devuelve la semilla del slider."""
     if randomize_seed:
-        return random.randint(0, MAX_SEED)
-    return int(seed)
+        new_seed = random.randint(0, MAX_SEED)
+        print(f"Generando semilla aleatoria: {new_seed}")
+        return new_seed
+    else:
+        print(f"Usando semilla fija: {int(seed)}")
+        return int(seed)
 
 @spaces.GPU(duration=180)
-def generate_texture_for_user_mesh(
+def generate_texture(
     input_image_path,
     input_mesh_path,
     guidance_scale,
     inference_steps,
-    seed,
-    randomize_seed,
+    seed, # Ahora este valor es el definitivo (aleatorio o fijo)
     reference_conditioning_scale,
     progress=gr.Progress(track_tqdm=True)
 ):
     """
-    Función principal que genera la textura para un modelo 3D proporcionado por el usuario.
+    Función principal que genera la textura. Ya no necesita el parámetro 'randomize_seed'.
     """
     if input_image_path is None:
         raise gr.Error("Por favor, sube una imagen de referencia para empezar.")
@@ -134,13 +110,14 @@ def generate_texture_for_user_mesh(
 
     print("Iniciando generación de textura para el modelo del usuario...")
     
-    seed = get_random_seed(randomize_seed, seed)
-    
+    # Actualizar la configuración del pipeline con los valores de la UI
     texture_model.config.guidance_scale = float(guidance_scale)
     texture_model.config.num_inference_steps = int(inference_steps)
     texture_model.config.reference_conditioning_scale = float(reference_conditioning_scale)
     
-    print(f"Parámetros: Pasos={inference_steps}, Escala Guía={guidance_scale}, Semilla={seed}")
+    # La semilla ya viene procesada
+    final_seed = int(seed)
+    print(f"Parámetros: Pasos={inference_steps}, Escala Guía={guidance_scale}, Semilla Final={final_seed}")
 
     print(f"Cargando malla desde: {input_mesh_path}")
     try:
@@ -157,7 +134,7 @@ def generate_texture_for_user_mesh(
         image=input_image_path, 
         mesh=user_mesh, 
         remove_bg=True,
-        seed=seed
+        seed=final_seed
     )
     
     save_name = str(uuid.uuid4())
@@ -169,9 +146,8 @@ def generate_texture_for_user_mesh(
     
     return textured_save_path
 
-
 # --------------------------------------------------------------------------
-# 5. INTERFAZ DE USUARIO CON GRADIO
+# 4. INTERFAZ DE USUARIO CON GRADIO
 # --------------------------------------------------------------------------
 
 with gr.Blocks(title="Step1X-3D Texture Generator") as demo:
@@ -196,19 +172,23 @@ with gr.Blocks(title="Step1X-3D Texture Generator") as demo:
         with gr.Column(scale=3):
             output_model = gr.Model3D(label="Resultado: Modelo Texturizado", height=600, clear_color=[0.0, 0.0, 0.0, 0.0])
 
+    # --- Lógica de la interfaz ---
+
     btn_generate.click(
-        fn=generate_texture_for_user_mesh,
+        fn=get_random_seed,
+        inputs=[randomize_seed, seed],
+        outputs=[seed]
+    ).then(
+        fn=generate_texture,
         inputs=[
             input_image,
             input_mesh,
             guidance_scale,
             inference_steps,
-            seed,
-            randomize_seed,
+            seed, 
             reference_conditioning_scale,
         ],
         outputs=[output_model]
     )
 
-# Lanza la aplicación (share=True no es necesario en HF Spaces)
 demo.launch(ssr_mode=False)