> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/generacion-3d/trellis-3d.md).

# 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.

{% hint style="success" %}
Todos los ejemplos se ejecutan en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## 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:

```bash
# 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

```bash
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

```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

```python
# 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

```python
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

```python
# 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

```python
# 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](https://github.com/microsoft/TRELLIS)
* [Documento: Structured 3D Latents for Scalable 3D Generation](https://arxiv.org/abs/2412.01506)
* [Marketplace de CLORE.AI](https://clore.ai/marketplace)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/generacion-3d/trellis-3d.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.