TRELLIS 3D-Generierung

Konvertiere Bilder mit Microsoft TRELLIS auf Clore.ai in 3D-Meshes und Gaussian Splats

TRELLIS von Microsoft Research wandelt ein einzelnes RGB-Bild in etwa 30 Sekunden auf einer RTX 3090 in ein hochwertiges 3D-Mesh, einen Gaussian Splat oder ein Radiance Field um. Unter der MIT-Lizenz veröffentlicht, ist es vollständig kostenlos für die kommerzielle Nutzung.

Alle Beispiele laufen auf GPU-Servern, die über die CLORE.AI-Marktplatz.

Hauptfunktionen

• Einzelbild → 3D — keine Multi-View-Aufnahmen, kein Textprompt erforderlich

• Mehrere Ausgabeformate — GLB-Mesh, Gaussian Splat (.ply), Radiance Field

• ~30 Sekunden pro Asset auf RTX 3090/4090

• MIT-Lizenz — kostenlos für die kommerzielle Nutzung

• Gradio-Weboberfläche für browserbasierte Interaktion enthalten

• Python-API für Pipeline-Integration und Batch-Verarbeitung

• Zero-Shot — funktioniert auf beliebigen Bildern ohne Feinabstimmung

Anforderungen

Komponente	Minimum	Empfohlen
GPU	RTX 3090 24 GB	RTX 4090 24 GB
VRAM	24 GB	24 GB
RAM	32 GB	64 GB
Festplatte	30 GB	60 GB
CUDA	12.8+	12.8+
Python	3.10	3.10

Clore.ai-Preise: RTX 4090 ≈ $0.14–0.42/Stunde · RTX 3090 ≈ $0.07–0.21/Stunde

TRELLIS benötigt 24 GB VRAM. Eine RTX 3090 ist die kleinste praktikable GPU.

Schnellstart

1. Umgebung einrichten

TRELLIS verwendet bestimmte Abhängigkeitsversionen — eine Conda-Umgebung wird dringend empfohlen:

# Umgebung erstellen und aktivieren
conda create -n trellis python=3.10 -y
conda activate trellis

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

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

# Abhängigkeiten installieren
pip install -r requirements.txt

# Zusätzliche Pakete für den Mesh-Export installieren
pip install kaolin -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/torch-2.1.0_cu121.html
pip install spconv-cu121

2. Die Gradio-Weboberfläche ausführen

python app.py --share

Dies startet eine Gradio-Oberfläche unter http://0.0.0.0:7860. Mit --share erhältst du eine öffentliche URL, die von jedem Browser aus zugänglich ist, nützlich beim Ausführen auf einem headless Clore.ai-Server.

Ein Bild hochladen, die Generierungsparameter anpassen und das resultierende 3D-Asset herunterladen.

3. Die Python-API verwenden

from trellis.pipelines import TrellisImageTo3DPipeline
from PIL import Image

# Pipeline laden (lädt beim ersten Ausführen die Modellgewichte herunter, ~5 GB)
pipeline = TrellisImageTo3DPipeline.from_pretrained("JeffreyXiang/TRELLIS-image-large")
pipeline.cuda()

# 3D aus einem Bild generieren
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. In verschiedene Formate exportieren

# Als GLB-Mesh exportieren (Spiel-Engines, Web-Viewer)
glb = pipeline.to_glb(
    outputs["gaussian"][0],
    outputs["mesh"][0],
    simplify=0.95,          # Polygonanzahl um 95 % reduzieren
    texture_size=1024,
)
glb.export("output.glb")

# Gaussian Splat als PLY exportieren
outputs["gaussian"][0].save_ply("output.ply")

# Mesh als OBJ exportieren
import trimesh
mesh = trimesh.Trimesh(
    vertices=outputs["mesh"][0].vertices.cpu().numpy(),
    faces=outputs["mesh"][0].faces.cpu().numpy(),
)
mesh.export("output.obj")

Anwendungsbeispiele

Mehrere Bilder stapelweise verarbeiten

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"Exported: {img_path.stem}.glb")

Generierungsqualität anpassen

# Höhere Qualität (langsamer, ~60 Sek.)
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,
    },
)

# Schnelle Vorschau (niedrigere Qualität, ~15 Sek.)
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,
    },
)

Gaussian Splat für 3D-Viewer extrahieren

# Als .ply speichern für Viewer wie SuperSplat, Luma oder den Three.js-Splat-Renderer
outputs["gaussian"][0].save_ply("scene.ply")

Leistungsreferenz

GPU	Schritte (12/12)	Zeit	Hinweise
RTX 4090	12 / 12	~25 Sek.	Bestes Preis-/Leistungsverhältnis
RTX 3090	12 / 12	~35 Sek.	Minimum für TRELLIS
A100 40G	12 / 12	~20 Sek.	Rechenzentrums-Option

Tipps

• PNG mit sauberem Hintergrund verwenden — Hintergrund entfernen mit rembg vor dem Einspeisen in TRELLIS für die beste Mesh-Qualität

• simplify=0.95 im GLB-Export reduziert die Polygonanzahl um 95 % und erhält dabei die visuelle Qualität — essenziell für Web-/Spieleinsatz

• Setze --share wenn du die Gradio-UI auf Clore.ai ausführst, um eine öffentliche URL zu erhalten

• Seed-Konsistenz — setze seed für reproduzierbare Ausgaben über mehrere Läufe hinweg

• Texturauflösung — verwende texture_size=2048 für drucktaugliche Texturen, 1024 für Echtzeitanwendungen

• Beim ersten Ausführen werden ~5 GB heruntergeladen an Modellgewichten — stelle genügend Festplattenspeicher sicher

• Gaussian Splats sind ideal für Rendering in Echtzeit; GLB-Meshes sind besser für Spiel-Engines und 3D-Druck

Fehlerbehebung

Problem	Lösung
CUDA-Speicher erschöpft	TRELLIS benötigt 24 GB VRAM — verwende RTX 3090/4090 oder A100
kaolin Installation schlägt fehl	Stimme die kaolin-Version exakt auf deine PyTorch- + CUDA-Version ab
spconv Importfehler	Installiere die richtige CUDA-Version: pip install spconv-cu121
Gradio-UI nicht erreichbar	Verwende --share für einen öffentlichen Tunnel oder öffne Port 7860 auf Clore.ai
Schlechte Mesh-Qualität	Stelle sicher, dass das Eingabebild einen sauberen/entfernten Hintergrund hat
Langsame erste Generierung	Modellgewichte werden beim ersten Ausführen heruntergeladen — nachfolgende Läufe sind schnell
GLB-Export schlägt fehl	Stelle sicher, trimesh und pygltflib sind installiert

Ressourcen

• TRELLIS GitHub

• Paper: Strukturierte 3D-Latents für skalierbare 3D-Generierung

• CLORE.AI-Marktplatz