Generación 3D con TRELLIS

Convierte imágenes en mallas 3D y splats gaussianos con Microsoft TRELLIS en Clore.ai

TRELLIS de Microsoft Research convierte una sola imagen RGB en una malla 3D de alta calidad, un splat gaussiano o un campo de radiancia en aproximadamente 30 segundos en una RTX 3090. Lanzado bajo la licencia MIT, es completamente gratuito para uso comercial.

Todos los ejemplos se ejecutan en servidores GPU alquilados a través de Marketplace de CLORE.AI.

Características clave

• Imagen única → 3D — no se requieren capturas de múltiples vistas, ni prompt de texto

• Múltiples formatos de salida — malla GLB, splat gaussiano (.ply), campo de radiancia

• ~30 segundos por activo en RTX 3090/4090

• licencia MIT — gratuito para uso comercial

• Interfaz web de Gradio incluida para interacción basada en navegador

• API de Python para integración en pipelines y procesamiento por lotes

• Sin entrenamiento previo — funciona con imágenes arbitrarias sin ajuste fino

Requisitos

Componente	Mínimo	Recomendado
GPU	RTX 3090 24 GB	RTX 4090 24 GB
VRAM	24 GB	24 GB
RAM	32 GB	64 GB
Disco	30 GB	60 GB
CUDA	12.8+	12.8+
Python	3.10	3.10

Precios de Clore.ai: RTX 4090 ≈ $0.14–0.42/h · RTX 3090 ≈ $0.07–0.21/h

TRELLIS requiere 24 GB de VRAM. Una RTX 3090 es la GPU mínima viable.

Inicio rápido

1. Configura el entorno

TRELLIS usa versiones específicas de dependencias — se recomienda encarecidamente un entorno conda:

# Crea y activa el entorno
conda create -n trellis python=3.10 -y
conda activate trellis

# Instala PyTorch con CUDA
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128

# Clona TRELLIS
git clone https://github.com/microsoft/TRELLIS.git
cd TRELLIS

# Instalar dependencias
pip install -r requirements.txt

# Instala paquetes adicionales para exportación de mallas
pip install kaolin -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/torch-2.1.0_cu121.html
pip install spconv-cu121

2. Ejecuta la interfaz web de Gradio

python app.py --share

Esto inicia una interfaz de Gradio en http://0.0.0.0:7860. Con --share obtienes una URL pública accesible desde cualquier navegador, útil cuando se ejecuta en un servidor Clore.ai sin interfaz gráfica.

Sube una imagen, ajusta los parámetros de generación y descarga el activo 3D resultante.

3. Usa la API de Python

from trellis.pipelines import TrellisImageTo3DPipeline
from PIL import Image

# Carga la canalización (descarga los pesos del modelo en la primera ejecución, ~5 GB)
pipeline = TrellisImageTo3DPipeline.from_pretrained("JeffreyXiang/TRELLIS-image-large")
pipeline.cuda()

# Genera 3D a partir de una imagen
image = Image.open("input.png")
outputs = pipeline.run(
    image,
    seed=42,
    sparse_structure_sampler_params={
        "steps": 12,
        "cfg_strength": 7.5,
    },
    slat_sampler_params={
        "steps": 12,
        "cfg_strength": 3.0,
    },
)

4. Exporta a diferentes formatos

# Exporta como malla GLB (motores de juego, visores web)
glb = pipeline.to_glb(
    outputs["gaussian"][0],
    outputs["mesh"][0],
    simplify=0.95,          # reduce el número de polígonos en un 95%
    texture_size=1024,
)
glb.export("output.glb")

# Exporta el splat gaussiano como PLY
outputs["gaussian"][0].save_ply("output.ply")

# Exporta la malla como OBJ
import trimesh
mesh = trimesh.Trimesh(
    vertices=outputs["mesh"][0].vertices.cpu().numpy(),
    faces=outputs["mesh"][0].faces.cpu().numpy(),
)
mesh.export("output.obj")

Ejemplos de uso

Procesamiento por lotes de múltiples imágenes

import glob
from pathlib import Path

input_dir = Path("/workspace/input-images")
output_dir = Path("/workspace/3d-output")
output_dir.mkdir(exist_ok=True)

for img_path in sorted(input_dir.glob("*.png")):
    image = Image.open(img_path)
    outputs = pipeline.run(image, seed=42)

    glb = pipeline.to_glb(
        outputs["gaussian"][0],
        outputs["mesh"][0],
        simplify=0.95,
        texture_size=1024,
    )
    glb.export(str(output_dir / f"{img_path.stem}.glb"))
    print(f"Exportado: {img_path.stem}.glb")

Ajustando la calidad de generación

# Mayor calidad (más lento, ~60 s)
outputs = pipeline.run(
    image,
    seed=42,
    sparse_structure_sampler_params={
        "steps": 20,
        "cfg_strength": 9.0,
    },
    slat_sampler_params={
        "steps": 20,
        "cfg_strength": 4.5,
    },
)

# Vista previa rápida (menor calidad, ~15 s)
outputs = pipeline.run(
    image,
    seed=42,
    sparse_structure_sampler_params={
        "steps": 6,
        "cfg_strength": 7.5,
    },
    slat_sampler_params={
        "steps": 6,
        "cfg_strength": 3.0,
    },
)

Extrae el splat gaussiano para visores 3D

# Guarda como .ply para visores como SuperSplat, Luma o el renderizador de splats de Three.js
outputs["gaussian"][0].save_ply("scene.ply")

Referencia de rendimiento

GPU	Pasos (12/12)	Tiempo	Notas
RTX 4090	12 / 12	~25 s	Mejor relación calidad/precio
RTX 3090	12 / 12	~35 s	Mínimo para TRELLIS
A100 40G	12 / 12	~20 s	Opción de centro de datos

Consejos

• Usa PNG con fondos limpios — elimina el fondo con rembg antes de alimentar TRELLIS para obtener la mejor calidad de malla

• simplify=0.95 en la exportación GLB reduce el número de polígonos en un 95% mientras preserva la calidad visual — esencial para uso web/juegos

• Establece --share al ejecutar la interfaz de Gradio en Clore.ai para obtener una URL pública

• Consistencia de la semilla — fija la semilla para obtener salidas reproducibles entre ejecuciones

• Resolución de textura — usa texture_size=2048 para texturas con calidad de impresión, 1024 para aplicaciones en tiempo real

• La primera ejecución descarga ~5 GB de pesos del modelo — asegúrate de tener suficiente espacio en disco

• Los splats gaussianos son ideales para renderizado en tiempo real; las mallas GLB son mejores para motores de juego e impresión 3D

Solución de problemas

Problema	Solución
CUDA sin memoria	TRELLIS necesita 24 GB de VRAM — usa RTX 3090/4090 o A100
kaolin falla la instalación	Haz coincidir exactamente la versión de kaolin con tu versión de PyTorch + CUDA
spconv error de importación	Instala la versión correcta de CUDA: pip install spconv-cu121
La interfaz de Gradio no es accesible	Usa --share para un túnel público, o expón el puerto 7860 en Clore.ai
Mala calidad de malla	Asegúrate de que la imagen de entrada tenga un fondo limpio o eliminado
Primera generación lenta	Los pesos del modelo se descargan en la primera ejecución — las ejecuciones posteriores son rápidas
Falla la exportación GLB	Asegúrate trimesh y pygltflib estén instalados

Recursos

• GitHub de TRELLIS

• Documento: Structured 3D Latents for Scalable 3D Generation

• Marketplace de CLORE.AI