TripoSR

Genera modelos 3D a partir de imágenes únicas con TripoSR en Clore.ai

Genera modelos 3D a partir de imágenes únicas en menos de un segundo.

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

Alquilar en CLORE.AI

1. Visita CLORE.AI Marketplace

2. Filtrar por tipo de GPU, VRAM y precio

3. Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)

4. Configura tu pedido:

   • Selecciona imagen Docker

   • Establece puertos (TCP para SSH, HTTP para interfaces web)

   • Agrega variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera el despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis Pedidos

• Interfaces web: Usa la URL del puerto HTTP

• SSH: ssh -p <port> root@<proxy-address>

¿Qué es TripoSR?

TripoSR de Stability AI y Tripo AI permite:

• Generación de malla 3D a partir de una sola imagen

• Velocidad de inferencia en menos de un segundo

• Mallas texturizadas de alta calidad

• Exportar a OBJ, GLB y otros formatos

Recursos

• GitHub: VAST-AI-Research/TripoSR

• HuggingFace: stabilityai/TripoSR

• Artículo: Artículo de TripoSR

• Demostración: Espacio de HuggingFace

Hardware recomendado

Componente	Mínimo	Recomendado	Óptimo
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	8GB	12GB	16GB
CPU	4 núcleos	8 núcleos	16 núcleos
RAM	16GB	32GB	64GB
Almacenamiento	SSD de 20 GB	50GB NVMe	100GB NVMe
Internet	100 Mbps	500 Mbps	1 Gbps

Despliegue rápido en CLORE.AI

Imagen Docker:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Puertos:

22/tcp
7860/http

Comando:

cd /workspace && \
git clone https://github.com/VAST-AI-Research/TripoSR.git && \
cd TripoSR && \
pip install -r requirements.txt && \
python gradio_app.py

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Instalación

git clone https://github.com/VAST-AI-Research/TripoSR.git
cd TripoSR
pip install -r requirements.txt

# Las descargas del modelo se realizan automáticamente en la primera ejecución

Lo que puedes crear

Juegos y RV

• Convertir arte conceptual en activos 3D

• Prototipado rápido de objetos de juego

• Generación de modelos de personajes

• Accesorios ambientales

Comercio electrónico

• Visualización 3D de productos

• Experiencias de prueba en RA

• Vistas de producto en 360 grados

• Salas de exposición virtuales

Arquitectura

• Modelos 3D rápidos a partir de bocetos

• Visualización de diseño de interiores

• Prototipos de muebles

• Generación de elementos de construcción

Educación

• Modelos 3D para materiales de aprendizaje

• Visualización científica

• Recreación de artefactos históricos

• Modelos de anatomía

Proyectos creativos

• Arte digital y NFT

• Activos para animación

• Preparación para impresión 3D

• Creación de memes y avatares

Uso básico

Línea de comandos

python run.py input_image.png \
    --output-dir output/ \
    --render

API de Python

import torch
from PIL import Image
from tsr.system import TSR
from tsr.utils import remove_background, save_video

# Cargar modelo
model = TSR.from_pretrained(
    "stabilityai/TripoSR",
    config_name="config.yaml",
    weight_name="model.ckpt"
)
model.to("cuda")

# Cargar y preprocesar imagen
image = Image.open("input.png")

# Generar malla 3D
with torch.no_grad():
    scene_codes = model([image], device="cuda")

# Extraer malla
meshes = model.extract_mesh(scene_codes)

# Guardar malla
meshes[0].export("output.obj")

Con eliminación de fondo

from tsr.system import TSR
from tsr.utils import remove_background
from PIL import Image

model = TSR.from_pretrained("stabilityai/TripoSR")
model.to("cuda")

# Cargar imagen y eliminar fondo
image = Image.open("photo.jpg")
image_no_bg = remove_background(image)

# Generar 3D
with torch.no_grad():
    scene_codes = model([image_no_bg], device="cuda")

mesh = model.extract_mesh(scene_codes)[0]
mesh.export("model.glb")  # Exportar como GLB para la web

Procesamiento por lotes

import os
from PIL import Image
import torch
from tsr.system import TSR
from tsr.utils import remove_background

model = TSR.from_pretrained("stabilityai/TripoSR")
model.to("cuda")

input_dir = "./images"
output_dir = "./3d_models"
os.makedirs(output_dir, exist_ok=True)

images_to_process = []
filenames = []

for filename in os.listdir(input_dir):
    if not filename.endswith(('.jpg', '.png')):
        continue

    image = Image.open(os.path.join(input_dir, filename))
    image_no_bg = remove_background(image)
    images_to_process.append(image_no_bg)
    filenames.append(filename)

# Procesar en lotes
batch_size = 4
for i in range(0, len(images_to_process), batch_size):
    batch = images_to_process[i:i+batch_size]
    batch_names = filenames[i:i+batch_size]

    with torch.no_grad():
        scene_codes = model(batch, device="cuda")

    meshes = model.extract_mesh(scene_codes)

    for mesh, name in zip(meshes, batch_names):
        output_name = name.rsplit('.', 1)[0] + '.obj'
        mesh.export(os.path.join(output_dir, output_name))
        print(f"Generado: {output_name}")

Formatos de exportación

from tsr.system import TSR
from PIL import Image

model = TSR.from_pretrained("stabilityai/TripoSR")
model.to("cuda")

image = Image.open("input.png")

with torch.no_grad():
    scene_codes = model([image], device="cuda")

mesh = model.extract_mesh(scene_codes)[0]

# Diferentes formatos de exportación
mesh.export("model.obj")   # Wavefront OBJ
mesh.export("model.glb")   # GLTF Binario (listo para la web)
mesh.export("model.ply")   # Formato PLY
mesh.export("model.stl")   # STL (impresión 3D)

Vista previa de render

from tsr.system import TSR
from tsr.utils import save_video
from PIL import Image
import torch

model = TSR.from_pretrained("stabilityai/TripoSR")
model.to("cuda")

image = Image.open("input.png")

with torch.no_grad():
    scene_codes = model([image], device="cuda")

# Renderizar video de 360 grados
render_images = model.render(
    scene_codes,
    n_views=30,
    return_type="pil"
)

save_video(render_images[0], "preview.mp4", fps=30)

Interfaz Gradio

import gradio as gr
import torch
from PIL import Image
from tsr.system import TSR
from tsr.utils import remove_background
import tempfile

model = TSR.from_pretrained("stabilityai/TripoSR")
model.to("cuda")

def generate_3d(image, remove_bg, output_format):
    if remove_bg:
        image = remove_background(image)

    with torch.no_grad():
        scene_codes = model([image], device="cuda")

    mesh = model.extract_mesh(scene_codes)[0]

    with tempfile.NamedTemporaryFile(suffix=f".{output_format}", delete=False) as f:
        mesh.export(f.name)
        return f.name, image

demo = gr.Interface(
    fn=generate_3d,
    inputs=[
        gr.Image(type="pil", label="Imagen de entrada"),
        gr.Checkbox(label="Eliminar fondo", value=True),
        gr.Dropdown(choices=["obj", "glb", "ply", "stl"], value="glb", label="Formato de salida")
    ],
    outputs=[
        gr.File(label="Modelo 3D"),
        gr.Image(label="Entrada procesada")
    ],
    title="TripoSR - Imagen a 3D",
    description="Genera modelos 3D a partir de imágenes únicas en segundos. Ejecutándose en servidores GPU de CLORE.AI."
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Con refinamiento de malla

from tsr.system import TSR
from PIL import Image
import torch

model = TSR.from_pretrained("stabilityai/TripoSR")
model.to("cuda")

image = Image.open("input.png")

with torch.no_grad():
    scene_codes = model([image], device="cuda")

# Extraer con mayor resolución
mesh = model.extract_mesh(
    scene_codes,
    resolution=256  # Mayor = más detalle, el valor predeterminado es 128
)[0]

mesh.export("high_detail.obj")

Rendimiento

Resolución	GPU	Velocidad	Calidad
128 (predeterminado)	RTX 3090	0.5s	Bueno
128	RTX 4090	0.3s	Bueno
256	RTX 4090	1.2s	Mejor
256	A100	0.8s	Mejor

Problemas comunes y soluciones

Mala calidad 3D

Problema: La malla generada se ve mal o distorsionada

Soluciones:

• Use imágenes con sujeto claro y fondo simple

• Elimine el fondo antes de procesar

• Use vista frontal del objeto

• Asegure una buena iluminación en la imagen fuente

# Siempre elimine el fondo para obtener mejores resultados
from tsr.utils import remove_background

image = Image.open("photo.jpg")
clean_image = remove_background(image)

La eliminación de fondo falla

Problema: La eliminación del fondo deja artefactos

Soluciones:

• Preprocese con una herramienta dedicada como rembg

• Edite manualmente el fondo de la imagen

• Use imágenes con fondos simples

pip install rembg

from rembg import remove
from PIL import Image

image = Image.open("photo.jpg")
image_no_bg = remove(image)
image_no_bg.save("clean.png")

Memoria insuficiente

Problema: OOM de CUDA en alta resolución

Soluciones:

# Use resolución más baja
mesh = model.extract_mesh(scene_codes, resolution=128)

# O limpie la caché entre lotes
import torch
torch.cuda.empty_cache()

La malla tiene agujeros

Problema: La malla generada tiene partes faltantes

Soluciones:

• Use extracción de mayor resolución

• Pruebe un ángulo de visión diferente del sujeto

• Postprocese la malla en Blender o MeshLab

• Use imágenes con visibilidad completa del objeto

Procesamiento lento

Problema: Toma demasiado tiempo por imagen

Soluciones:

• Use procesamiento por lotes para múltiples imágenes

• Resolución más baja para prototipos

• Use GPU RTX 4090 o A100

Solución de problemas

Calidad de malla 3D deficiente

• Use imágenes con bordes de objeto claros

• Elimine o enmascare el fondo

• Las vistas frontales funcionan mejor

La exportación falla

• Verifique que exista el directorio de salida

• Verifique que el formato de malla sea compatible

• Asegúrate de tener suficiente espacio en disco

Falta la textura

• Algunas exportaciones no incluyen textura

• Use el formato GLB para salida con textura

• Verifique la configuración de exportación de materiales

Fuera de memoria

• TripoSR es eficiente pero necesita 6 GB+

• Reduzca la resolución de salida

• Procese una imagen a la vez

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Los precios varían según el proveedor y la demanda. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

• Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)

• Paga con CLORE tokens

• Compara precios entre diferentes proveedores

Próximos pasos

• Stable Diffusion - Generar imágenes de entrada

• IC-Light - Reiluminar imágenes antes de 3D

• ComfyUI - Integración de flujo de trabajo