TripoSR

Generiere 3D-Modelle aus einzelnen Bildern mit TripoSR auf Clore.ai

Erzeuge 3D-Modelle aus einzelnen Bildern in weniger als einer Sekunde.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

2. Filtern nach GPU-Typ, VRAM und Preis

3. Wähle On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfiguriere deine Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Bei Bedarf Umgebungsvariablen hinzufügen

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf die Bereitstellung warten

Greife auf deinen Server zu

• Verbindungsdetails finden in Meine Bestellungen

• Web-Oberflächen: Verwende die HTTP-Port-URL

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

Was ist TripoSR?

TripoSR von Stability AI und Tripo AI ermöglicht:

• Generierung von 3D-Meshes aus einem einzelnen Bild

• Inferenzgeschwindigkeit unter einer Sekunde

• Hochwertige texturierte Meshes

• Export nach OBJ, GLB und anderen Formaten

Ressourcen

• GitHub: VAST-AI-Research/TripoSR

• HuggingFace: stabilityai/TripoSR

• Paper: TripoSR-Paper

• Demo: HuggingFace Space

Empfohlene Hardware

Komponente	Minimum	Empfohlen	Optimal
GPU	RTX 3060 12 GB	RTX 4080 16 GB	RTX 4090 24GB
VRAM	8 GB	12 GB	16 GB
CPU	4 Kerne	8 Kerne	16 Kerne
RAM	16 GB	32 GB	64 GB
Speicher	20GB SSD	50 GB NVMe	100 GB NVMe
Internet	100 Mbit/s	500 Mbit/s	1 Gbit/s

Schnellbereitstellung auf CLORE.AI

Docker-Image:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Ports:

22/tcp
7860/http

Befehl:

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

Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

1. Gehe zu Meine Bestellungen Seite

2. Klicke auf deine Bestellung

3. Finde die http_pub URL (z. B. abc123.clorecloud.net)

Verwende https://YOUR_HTTP_PUB_URL anstelle von localhost in den folgenden Beispielen.

Installation

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

# Das Modell wird beim ersten Ausführen automatisch heruntergeladen

Was du erstellen kannst

Gaming & VR

• Konzeptkunst in 3D-Assets umwandeln

• Schnelles Prototyping für Spielobjekte

• Generierung von Charaktermodellen

• Umgebungsrequisiten

E-Commerce

• 3D-Visualisierung von Produkten

• AR-Anprobeerlebnisse

• 360-Grad-Produktansichten

• Virtuelle Showrooms

Architektur

• Schnelle 3D-Modelle aus Skizzen

• Visualisierung von Innenarchitektur

• Möbelprototypen

• Generierung von Bauelementen

Bildung

• 3D-Modelle für Lernmaterialien

• Wissenschaftliche Visualisierung

• Rekonstruktion historischer Artefakte

• Anatomiemodelle

Kreative Projekte

• Digitale Kunst und NFTs

• Animations-Assets

• Vorbereitung für den 3D-Druck

• Meme- und Avatar-Erstellung

Grundlegende Verwendung

Kommandozeile

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

Python-API

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

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

# Bild laden und vorverarbeiten
image = Image.open("input.png")

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

# Mesh extrahieren
meshes = model.extract_mesh(scene_codes)

# Mesh speichern
meshes[0].export("output.obj")

Mit Hintergrundentfernung

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

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

# Bild laden und Hintergrund entfernen
image = Image.open("photo.jpg")
image_no_bg = remove_background(image)

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

mesh = model.extract_mesh(scene_codes)[0]
mesh.export("model.glb")  # Als GLB für das Web exportieren

Batch-Verarbeitung

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)

# In Batches verarbeiten
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"Generiert: {output_name}")

Exportformate

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]

# Verschiedene Exportformate
mesh.export("model.obj")   # Wavefront OBJ
mesh.export("model.glb")   # GLTF Binary (webbereit)
mesh.export("model.ply")   # PLY-Format
mesh.export("model.stl")   # STL (3D-Druck)

Vorschauvideo rendern

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")

# 360-Grad-Video rendern
render_images = model.render(
    scene_codes,
    n_views=30,
    return_type="pil"
)

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

Gradio-Oberfläche

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="Eingabebild"),
        gr.Checkbox(label="Hintergrund entfernen", value=True),
        gr.Dropdown(choices=["obj", "glb", "ply", "stl"], value="glb", label="Ausgabeformat")
    ],
    outputs=[
        gr.File(label="3D-Modell"),
        gr.Image(label="Verarbeitete Eingabe")
    ],
    title="TripoSR - Bild zu 3D",
    description="Erzeuge 3D-Modelle aus einzelnen Bildern in Sekunden. Läuft auf CLORE.AI GPU-Servern."
)

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

Mit Mesh-Verfeinerung

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")

# Mit höherer Auflösung extrahieren
mesh = model.extract_mesh(
    scene_codes,
    resolution=256  # Höher = mehr Details, Standard ist 128
)[0]

mesh.export("high_detail.obj")

Leistung

Auflösung	GPU	Geschwindigkeit	Qualität
128 (Standard)	RTX 3090	0.5s	Gut
128	RTX 4090	0.3s	Gut
256	RTX 4090	1.2s	Besser
256	A100	0.8s	Besser

Häufige Probleme & Lösungen

Schlechte 3D-Qualität

Problem: Das generierte Mesh sieht falsch aus oder ist verzerrt

Lösungen:

• Verwende Bilder mit klarem Motiv und einfachem Hintergrund

• Vor der Verarbeitung den Hintergrund entfernen

• Verwende die frontale Ansicht des Objekts

• Sorge für gute Beleuchtung im Quellbild

# Für beste Ergebnisse immer den Hintergrund entfernen
from tsr.utils import remove_background

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

Hintergrundentfernung schlägt fehl

Problem: Die Hintergrundentfernung hinterlässt Artefakte

Lösungen:

• Mit einem speziellen Tool wie rembg vorverarbeiten

• Den Bildhintergrund manuell bearbeiten

• Verwende Bilder mit einfachem Hintergrund

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")

Speicher erschöpft

Problem: CUDA-OOM bei hoher Auflösung

Lösungen:

# Niedrigere Auflösung verwenden
mesh = model.extract_mesh(scene_codes, resolution=128)

# Oder den Cache zwischen den Batches leeren
import torch
torch.cuda.empty_cache()

Mesh hat Löcher

Problem: Dem generierten Mesh fehlen Teile

Lösungen:

• Eine Extraktion mit höherer Auflösung verwenden

• Versuche einen anderen Betrachtungswinkel des Motivs

• Mesh in Blender oder MeshLab nachbearbeiten

• Verwende Bilder, bei denen das Objekt vollständig sichtbar ist

Langsame Verarbeitung

Problem: Dauert pro Bild zu lange

Lösungen:

• Batch-Verarbeitung für mehrere Bilder verwenden

• Niedrigere Auflösung für Prototyping verwenden

• Eine RTX 4090 oder A100 GPU verwenden

Fehlerbehebung

Schlechte 3D-Mesh-Qualität

• Verwende Bilder mit klaren Objektgrenzen

• Hintergrund entfernen oder maskieren

• Frontalansichten funktionieren am besten

Export schlägt fehl

• Prüfe, ob das Ausgabeverzeichnis existiert

• Verifizieren, dass das Mesh-Format unterstützt wird

• Stelle sicher, dass genügend Speicherplatz vorhanden ist

Textur fehlt

• Einige Exporte enthalten keine Textur

• Verwende das GLB-Format für texturierte Ausgaben

• Überprüfe die Material-Exporteinstellungen

Speicher voll

• TripoSR ist effizient, benötigt aber 6 GB+

• Ausgabeauflösung reduzieren

• Jeweils ein Bild verarbeiten

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (Stand 2024):

GPU	Stundensatz	Tagessatz	4-Stunden-Sitzung
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

Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI-Marktplatz für aktuelle Preise.

Geld sparen:

• Nutzen Sie den Spot Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf

• Bezahlen Sie mit CLORE Tokens

• Vergleichen Sie Preise zwischen verschiedenen Anbietern

Nächste Schritte

• Stable Diffusion - Eingabebilder generieren

• IC-Light - Bilder vor 3D neu ausleuchten

• ComfyUI - Workflow-Integration