Génération 3D TRELLIS

Convertissez des images en maillages 3D et en splats gaussiens avec Microsoft TRELLIS sur Clore.ai

TRELLIS de Microsoft Research convertit une seule image RVB en un maillage 3D de haute qualité, un splat gaussien ou un champ de radiance en environ 30 secondes sur une RTX 3090. Publié sous licence MIT, il est entièrement gratuit pour un usage commercial.

Tous les exemples s’exécutent sur des serveurs GPU loués via la place de marché CLORE.AI.

Caractéristiques clés

• Une seule image → 3D — aucune capture multi-vue, aucun prompt textuel requis

• Plusieurs formats de sortie — maillage GLB, splat gaussien (.ply), champ de radiance

• ~30 secondes par asset sur RTX 3090/4090

• licence MIT — gratuit pour un usage commercial

• Interface web Gradio incluse pour une interaction via navigateur

• API Python pour l'intégration dans des pipelines et le traitement par lots

• Sans apprentissage préalable — fonctionne sur n'importe quelles images sans ajustement fin

Exigences

Composant	Minimum	Recommandé
GPU	RTX 3090 24 Go	RTX 4090 24 Go
VRAM	24 Go	24 Go
RAM	32 Go	64 Go
Disque	30 Go	60 Go
CUDA	12.8+	12.8+
Python	3.10	3.10

Tarification Clore.ai : RTX 4090 ≈ 0,14–0,42 $/h · RTX 3090 ≈ 0,07–0,21 $/h

TRELLIS nécessite 24 Go de VRAM. Une RTX 3090 est le GPU minimum viable.

Démarrage rapide

1. Configurer l'environnement

TRELLIS utilise des versions spécifiques des dépendances — un environnement conda est fortement recommandé :

# Créer et activer l'environnement
conda create -n trellis python=3.10 -y
conda activate trellis

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

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

# Installer les dépendances
pip install -r requirements.txt

# Installer des paquets supplémentaires pour l'export du maillage
pip install kaolin -f https://nvidia-kaolin.s3.us-east-2.amazonaws.com/torch-2.1.0_cu121.html
pip install spconv-cu121

2. Lancer l'interface web Gradio

python app.py --share

Cela lance une interface Gradio sur http://0.0.0.0:7860. Avec --share vous obtenez une URL publique accessible depuis n'importe quel navigateur, utile lors de l'exécution sur un serveur Clore.ai sans interface graphique.

Téléchargez une image, ajustez les paramètres de génération et téléchargez l'asset 3D résultant.

3. Utiliser l'API Python

from trellis.pipelines import TrellisImageTo3DPipeline
from PIL import Image

# Charger le pipeline (télécharge les poids du modèle au premier lancement, ~5 Go)
pipeline = TrellisImageTo3DPipeline.from_pretrained("JeffreyXiang/TRELLIS-image-large")
pipeline.cuda()

# Générer du 3D à partir d'une image
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. Exporter vers différents formats

# Exporter comme maillage GLB (moteurs de jeu, visionneuses web)
glb = pipeline.to_glb(
    outputs["gaussian"][0],
    outputs["mesh"][0],
    simplify=0.95,          # réduire le nombre de polygones de 95 %
    texture_size=1024,
)
glb.export("output.glb")

# Exporter le splat gaussien au format PLY
outputs["gaussian"][0].save_ply("output.ply")

# Exporter le maillage au format OBJ
import trimesh
mesh = trimesh.Trimesh(
    vertices=outputs["mesh"][0].vertices.cpu().numpy(),
    faces=outputs["mesh"][0].faces.cpu().numpy(),
)
mesh.export("output.obj")

Exemples d'utilisation

Traitement par lots de plusieurs images

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

Ajuster la qualité de génération

# Qualité supérieure (plus lent, ~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,
    },
)

# Aperçu rapide (qualité inférieure, ~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,
    },
)

Extraire le splat gaussien pour les visionneuses 3D

# Enregistrer en .ply pour des visionneuses comme SuperSplat, Luma ou le rendu de splat Three.js
outputs["gaussian"][0].save_ply("scene.ply")

Référence de performance

GPU	Étapes (12/12)	Temps	Remarques
RTX 4090	12 / 12	~25 s	Meilleur rapport prix/performance
RTX 3090	12 / 12	~35 s	Minimum pour TRELLIS
A100 40 Go	12 / 12	~20 s	Option datacenter

Conseils

• Utilisez des PNG avec des arrière-plans propres — supprimez l'arrière-plan avec rembg avant de l'envoyer à TRELLIS pour une qualité de maillage optimale

• simplify=0.95 dans l'export GLB réduit le nombre de polygones de 95 % tout en préservant la qualité visuelle — essentiel pour une utilisation web/jeu

• Définir --share lors de l'exécution de l'interface Gradio sur Clore.ai pour obtenir une URL publique

• Cohérence de la graine — fixez la graine pour des sorties reproductibles d'une exécution à l'autre

• Résolution de la texture — utilisez texture_size=2048 pour des textures de qualité impression, 1024 pour les applications en temps réel

• Le premier lancement télécharge ~5 Go de poids du modèle — assurez-vous d'avoir suffisamment d'espace disque

• Les splats gaussiens sont idéaux pour le rendu en temps réel ; les maillages GLB conviennent mieux aux moteurs de jeu et à l'impression 3D

Dépannage

Problème	Solution
Mémoire CUDA insuffisante	TRELLIS a besoin de 24 Go de VRAM — utilisez une RTX 3090/4090 ou une A100
kaolin installation échoue	Faites correspondre exactement la version de kaolin à votre version de PyTorch + CUDA
spconv erreur d'importation	Installez la version CUDA correcte : pip install spconv-cu121
Interface Gradio inaccessible	Utilisez --share pour un tunnel public, ou exposez le port 7860 sur Clore.ai
Qualité de maillage médiocre	Assurez-vous que l'image d'entrée ait un fond propre/supprimé
Première génération lente	Les poids du modèle sont téléchargés au premier lancement — les exécutions suivantes sont rapides
L'exportation GLB échoue	Assurez-vous trimesh et pygltflib sont installés

Ressources

• GitHub de TRELLIS

• Article : Latents 3D structurés pour une génération 3D évolutive

• la place de marché CLORE.AI