# TripoSR

Générez des modèles 3D à partir d'images uniques en moins d'une seconde.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Qu'est-ce que TripoSR ?

TripoSR par Stability AI et Tripo AI permet :

* Génération de maillage 3D à partir d'une seule image
* Vitesse d'inférence inférieure à la seconde
* Maillages texturés de haute qualité
* Export vers OBJ, GLB et autres formats

## Ressources

* **GitHub :** [VAST-AI-Research/TripoSR](https://github.com/VAST-AI-Research/TripoSR)
* **HuggingFace :** [stabilityai/TripoSR](https://huggingface.co/stabilityai/TripoSR)
* **Article :** [Article TripoSR](https://arxiv.org/abs/2403.02151)
* **Démo :** [Espace HuggingFace](https://huggingface.co/spaces/stabilityai/TripoSR)

## Matériel recommandé

| Composant | Minimum       | Recommandé    | Optimal       |
| --------- | ------------- | ------------- | ------------- |
| GPU       | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM      | 8 Go          | 12Go          | 16Go          |
| CPU       | 4 cœurs       | 8 cœurs       | 16 cœurs      |
| RAM       | 16Go          | 32Go          | 64Go          |
| Stockage  | SSD 20 Go     | 50Go NVMe     | 100Go NVMe    |
| Internet  | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## Déploiement rapide sur CLORE.AI

**Image Docker :**

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

**Ports :**

```
22/tcp
7860/http
```

**Commande :**

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

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Installation

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

# Téléchargement du modèle automatique lors de la première exécution
```

## Ce que vous pouvez créer

### Jeux & Réalité virtuelle

* Convertir l'art conceptuel en assets 3D
* Prototypage rapide d'objets de jeu
* Génération de modèles de personnages
* Accessoires environnementaux

### E-commerce

* Visualisation 3D de produits
* Expériences d'essayage en réalité augmentée
* Vues produits à 360 degrés
* Showrooms virtuels

### Architecture

* Modèles 3D rapides à partir d'esquisses
* Visualisation en design d'intérieur
* Prototypes de mobilier
* Génération d'éléments de construction

### Éducation

* Modèles 3D pour supports pédagogiques
* Visualisation scientifique
* Recréation d'artefacts historiques
* Modèles d'anatomie

### Projets créatifs

* Art numérique et NFT
* Assets d'animation
* Préparation pour l'impression 3D
* Création de mèmes et d'avatars

## Utilisation de base

### Ligne de commande

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

### API Python

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

# Charger le modèle
model = TSR.from_pretrained(
    "stabilityai/TripoSR",
    config_name="config.yaml",
    weight_name="model.ckpt"
)
model.to("cuda")

# Charger et prétraiter l'image
image = Image.open("input.png")

# Générer le maillage 3D
with torch.no_grad():
    scene_codes = model([image], device="cuda")

# Extraire le maillage
meshes = model.extract_mesh(scene_codes)

# Enregistrer le maillage
meshes[0].export("output.obj")
```

### Avec suppression d'arrière-plan

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

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

# Charger l'image et supprimer l'arrière-plan
image = Image.open("photo.jpg")
image_no_bg = remove_background(image)

# Générer le 3D
with torch.no_grad():
    scene_codes = model([image_no_bg], device="cuda")

mesh = model.extract_mesh(scene_codes)[0]
mesh.export("model.glb")  # Exporter en GLB pour le web
```

## Traitement par lots

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

# Traiter par lots
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"Généré : {output_name}")
```

## Formats d'export

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

# Différents formats d'export
mesh.export("model.obj")   # Wavefront OBJ
mesh.export("model.glb")   # GLTF binaire (prêt pour le web)
mesh.export("model.ply")   # Format PLY
mesh.export("model.stl")   # STL (impression 3D)
```

## Rendre une vidéo d'aperçu

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

# Rendre une vidéo à 360 degrés
render_images = model.render(
    scene_codes,
    n_views=30,
    return_type="pil"
)

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

## Interface Gradio

```python
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="Image d'entrée"),
        gr.Checkbox(label="Remove Background", value=True),
        gr.Dropdown(choices=["obj", "glb", "ply", "stl"], value="glb", label="Output Format")
    ],
    outputs=[
        gr.File(label="3D Model"),
        gr.Image(label="Processed Input")
    ],
    title="TripoSR - Image to 3D",
    description="Generate 3D models from single images in seconds. Running on CLORE.AI GPU servers."
)

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

## Avec Affinement du Maillage

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

# Extraire avec une résolution plus élevée
mesh = model.extract_mesh(
    scene_codes,
    resolution=256  # Plus élevé = plus de détails, la valeur par défaut est 128
)[0]

mesh.export("high_detail.obj")
```

## Performances

| Résolution       | GPU      | Vitesse | Qualité  |
| ---------------- | -------- | ------- | -------- |
| 128 (par défaut) | RTX 3090 | 0,5 s   | Bon      |
| 128              | RTX 4090 | 0,3 s   | Bon      |
| 256              | RTX 4090 | 1,2 s   | Meilleur |
| 256              | A100     | 0,8 s   | Meilleur |

## Problèmes courants et solutions

### Mauvaise qualité 3D

**Problème :** Le maillage généré semble incorrect ou déformé

**Solutions :**

* Utilisez des images avec un sujet clair et un arrière-plan simple
* Supprimez l'arrière-plan avant le traitement
* Utilisez une vue frontale de l'objet
* Assurez un bon éclairage sur l'image source

```python

# Toujours supprimer l'arrière-plan pour de meilleurs résultats
from tsr.utils import remove_background

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

### La suppression de l'arrière-plan échoue

**Problème :** La suppression de l'arrière-plan laisse des artefacts

**Solutions :**

* Prétraitez avec un outil dédié comme rembg
* Modifiez manuellement l'arrière-plan de l'image
* Utilisez des images avec des arrière-plans simples

```bash
pip install rembg
```

```python
from rembg import remove
from PIL import Image

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

### Mémoire insuffisante

**Problème :** OOM CUDA à haute résolution

**Solutions :**

```python

# Utiliser une résolution inférieure
mesh = model.extract_mesh(scene_codes, resolution=128)

# Ou vider le cache entre les lots
import torch
torch.cuda.empty_cache()
```

### Le maillage a des trous

**Problème :** Le maillage généré a des parties manquantes

**Solutions :**

* Utilisez une extraction à plus haute résolution
* Essayez un angle de vue différent du sujet
* Post-traitez le maillage dans Blender ou MeshLab
* Utilisez des images avec une visibilité complète de l'objet

### Traitement lent

**Problème :** Prend trop de temps par image

**Solutions :**

* Utilisez le traitement par lots pour plusieurs images
* Réduisez la résolution pour le prototypage
* Utilisez un GPU RTX 4090 ou A100

## Dépannage

### Qualité du maillage 3D faible

* Utilisez des images avec des contours d'objet nets
* Supprimez ou masquez l'arrière-plan
* Les vues frontales fonctionnent mieux

### L'export échoue

* Vérifiez que le répertoire de sortie existe
* Vérifiez que le format de maillage est pris en charge
* Assurez-vous d'avoir suffisamment d'espace disque

### Texture manquante

* Certaines exportations n'incluent pas la texture
* Utilisez le format GLB pour une sortie texturée
* Vérifiez les paramètres d'export des matériaux

{% hint style="danger" %}
**Mémoire insuffisante**
{% endhint %}

* TripoSR est efficace mais nécessite 6 Go+
* Réduisez la résolution de sortie
* Traitez une image à la fois

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

| GPU       | Tarif horaire | Tarif journalier | Session de 4 heures |
| --------- | ------------- | ---------------- | ------------------- |
| 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             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* Stable Diffusion - Générer des images d'entrée
* [IC-Light](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/iclight) - Re-éclairer les images avant le 3D
* ComfyUI - Intégration de workflow