> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/generation-video/cubecomposer-360-video.md).

# CubeComposer 4K 360° Video

> **CubeComposer** (CVPR 2026) est un modèle de diffusion autorégressif spatio-temporel qui génère **une vidéo panoramique 360° 4K native** à partir d’une vidéo standard en perspective. Construit sur le modèle de fondation vidéo Wan, entraîné sur 11 832 clips haute résolution. C’est le premier modèle ouvert capable de générer nativement du 360° en 4K — permettant la création de contenu VR, les visites virtuelles et les médias immersifs sur du matériel GPU grand public.

## Pourquoi c’est important

La vidéo 360° a traditionnellement nécessité des dispositifs de capture spécialisés (plusieurs caméras, logiciels d’assemblage, post-traitement coûteux). CubeComposer change cela :

* **Entrée**: toute vidéo prise par une caméra standard (objectif unique, caméra de téléphone, dashcam)
* **Sortie**: vidéo équirectangulaire 4K 360° native
* **Méthode**: décompose les panoramas en faces de cubemap, génère chaque face de manière autorégressive avec cohérence spatiale
* **Qualité**: surpasse nettement les approches précédentes d’assemblage et d’outpainting

## Configuration matérielle requise

| Configuration  | VRAM  | Résolution           | Vitesse       |
| -------------- | ----- | -------------------- | ------------- |
| RTX 4090 24 Go | 24GB  | 4K 360° (30 images)  | \~8 min/clip  |
| RTX 5090 32 Go | 32 Go | 4K 360° (60 images)  | \~6 min/clip  |
| 2× RTX 4090    | 48GB  | 4K 360° (120 images) | \~9 min/clip  |
| A100 80 Go     | 80 Go | 4K 360° (240 images) | \~12 min/clip |

**Minimum**: RTX 4090 24 Go (ou GPU équivalent avec 24 Go+ de VRAM)

> Sur Clore.ai : RTX 4090 à partir de **0,14–0,42 $/h en spot** — un clip de 2 minutes coûte environ 0,40 $.

## Installation

```bash
# Cloner le dépôt
git clone https://github.com/TencentARC/CubeComposer
cd cubecomposer

# Installer les dépendances (Python 3.10+, CUDA 12.8+)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
pip install -r requirements.txt

# Télécharger les poids du modèle (~18 Go)
python scripts/download_weights.py --model cubecomposer-4k-v1
```

### Docker (recommandé pour Clore.ai)

```bash
# Pas d’image Docker officielle — installez depuis les sources :
git clone https://github.com/TencentARC/CubeComposer /workspace/CubeComposer
cd /workspace/CubeComposer
pip install -r requirements.txt
python app.py --share --listen 0.0.0.0 --port 7860
```

## Démarrage rapide

### CLI : Vidéo en perspective → 4K 360°

```bash
# Utilisation de base : vidéo d’entrée en perspective, sortie équirectangulaire 4K
python generate_360.py \\
  --input /workspace/input_video.mp4 \\
  --output /workspace/output_360.mp4 \\
  --resolution 4096x2048 \\
  --frames 30 \\
  --fps 30

# Qualité supérieure : plus d’étapes, clip plus long
python generate_360.py \\
  --input /workspace/walk_through_park.mp4 \\
  --output /workspace/park_360_4k.mp4 \\
  --resolution 4096x2048 \\
  --frames 60 \\
  --num_inference_steps 50 \\
  --guidance_scale 7.5 \\
  --fps 30
```

### API Python

```python
from cubecomposer import CubeComposerPipeline
import torch

# Charger le pipeline
pipe = CubeComposerPipeline.from_pretrained(
    "cubecomposer/cubecomposer-4k-v1",
    torch_dtype=torch.bfloat16
).to("cuda")

# Générer une vidéo 360° à partir d’une entrée en perspective
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),  # 4K équirectangulaire
    num_inference_steps=50,
    guidance_scale=7.5,
    cubemap_size=1024  # taille de chaque face du cubemap
)

# Enregistrer au format MP4 équirectangulaire standard
output.save("output_360.mp4", fps=30)
print(f"Vidéo 4K 360° générée : output_360.mp4")
```

### Interface Web Gradio

```python
import gradio as gr
from cubecomposer import CubeComposerPipeline
import torch

pipe = CubeComposerPipeline.from_pretrained(
    "cubecomposer/cubecomposer-4k-v1",
    torch_dtype=torch.bfloat16
).to("cuda")

def generate_360(video, frames, steps):
    output = pipe(
        input_video_path=video,
        num_frames=int(frames),
        resolution=(4096, 2048),
        num_inference_steps=int(steps)
    )
    output.save("/tmp/output_360.mp4", fps=30)
    return "/tmp/output_360.mp4"

demo = gr.Interface(
    fn=generate_360,
    inputs=[
        gr.Video(label="Vidéo d’entrée en perspective"),
        gr.Slider(10, 120, value=30, label="Nombre d’images"),
        gr.Slider(20, 80, value=50, label="Étapes d’inférence (qualité)")
    ],
    outputs=gr.Video(label="Sortie 4K 360°"),
    title="CubeComposer — génération de vidéo 4K 360°",
    description="Téléversez n’importe quelle vidéo en perspective → obtenez une vidéo panoramique 4K 360° native"
)

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

## Déployer sur Clore.ai : étape par étape

### 1. Louez une RTX 4090

1. Accédez à [clore.ai/marketplace](https://clore.ai/marketplace)
2. Filtre : GPU avec **24 Go+ de VRAM** (RTX 4090 recommandée)
3. Prix spot : \~1,20–2,50 $/h selon la disponibilité
4. Sélectionnez **Docker personnalisé** ou **Ubuntu** image

### 2. Configuration via SSH

```bash
# Connectez-vous à votre serveur Clore
ssh root@<server-ip>

# Configuration en une seule ligne
git clone https://github.com/TencentARC/CubeComposer && \\
  cd cubecomposer && \\
  pip install -r requirements.txt && \
  python scripts/download_weights.py && \\
  python app.py --port 7860 --host 0.0.0.0
```

### 3. Accédez à l’interface

Ouvrez `http://<server-ip>:7860` dans votre navigateur pour utiliser l’interface Gradio.

## Flux de travail : vidéo de téléphone → 4K 360° prête pour la VR

```bash
# Étape 1 : téléversez la vidéo du téléphone sur le serveur
scp ~/my_video.mp4 root@<server-ip>:/workspace/

# Étape 2 : générez la version 4K 360°
ssh root@<server-ip> "cd cubecomposer && python generate_360.py \\
  --input /workspace/my_video.mp4 \\
  --output /workspace/my_video_360_4k.mp4 \\
  --resolution 4096x2048 --frames 60"

# Étape 3 : ajoutez les métadonnées 360° pour YouTube/les casques VR
ffmpeg -i my_video_360_4k.mp4 \\
  -c copy \\
  -metadata:s:v:0 spherical=equirectangular \\
  my_video_360_4k_vr.mp4

# Étape 4 : téléchargez le résultat
scp root@<server-ip>:/workspace/my_video_360_4k_vr.mp4 ~/
```

## Intégration Spectrum : accélération ×4,79 sur Wan2.1

Le **Accélérateur Spectrum** (CVPR 2026) — un prévisionneur spectral de caractéristiques de diffusion sans entraînement utilisant des polynômes de Tchebychev — peut être appliqué à la base Wan2.1 sous-jacente de CubeComposer pour des accélérations significatives :

```python
from cubecomposer import CubeComposerPipeline
from spectrum_accelerator import SpectrumAccelerator
import torch

pipe = CubeComposerPipeline.from_pretrained(
    "cubecomposer/cubecomposer-4k-v1",
    torch_dtype=torch.bfloat16
).to("cuda")

# Appliquez Spectrum pour une accélération ×4,79 sans perte de qualité
accelerator = SpectrumAccelerator(pipe.unet, order=8)  # ordre de Tchebychev
pipe.unet = accelerator

# Génère désormais à environ ×4,79 la vitesse d’origine
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),
    num_inference_steps=50  # qualité effective d’environ 240 étapes
)
output.save("output_fast_360.mp4")
```

## Conseils de qualité

1. **La qualité de la vidéo d’entrée compte** — une entrée à plus haute résolution = une meilleure sortie 360°
2. **Images stables** — les tremblements à main levée réduisent la cohérence entre les faces du cubemap
3. **Bon éclairage** — évitez les contrastes extrêmes (ciel surexposé + intérieur sombre)
4. **Clips plus longs** — 30 images ou plus offrent une meilleure cohérence temporelle
5. **Résolution des faces** — `--cubemap_size 1024` est le juste milieu (2048 pour les travaux critiques, coûte 4× plus de VRAM)

## Cas d’usage

* **Création de contenu VR** — convertissez n’importe quelle séquence pour Meta Quest, Apple Vision Pro
* **Visites virtuelles de biens** — transformez des vidéos de visite en tours 360°
* **Contenu de voyage** — partagez des expériences de voyage immersives
* **Visualisation architecturale** — visites intérieures/extérieures 360°
* **Documentation d’événements** — convertissez les enregistrements d’événements en rediffusions immersives
* **Ressources pour le jeu vidéo** — générez des références d’environnements 360°

## Estimation des coûts pour le flux de production

| Tâche                                | Coût Clore.ai            |
| ------------------------------------ | ------------------------ |
| Clip de 5 secondes (30 images, 4K)   | \~0,30 $ (spot RTX 4090) |
| Clip de 10 secondes (60 images, 4K)  | \~$0.50                  |
| Clip de 30 secondes (180 images, 4K) | \~$1.20                  |
| Lot : 100 clips (5 s chacun)         | \~$30                    |

## Guides associés

* [Génération vidéo Wan2.1](/guides/guides_v2-fr/generation-video/wan-video.md) — le modèle de fondation à la base de CubeComposer
* [FramePack](/guides/guides_v2-fr/generation-video/framepack.md) — génération efficace de longues vidéos (6 Go de VRAM !)
* [Vidéo LTX-2](/guides/guides_v2-fr/generation-video/ltx-video-2.md) — génération vidéo latente rapide
* [ComfyUI](/guides/guides_v2-fr/generation-dimages/comfyui.md) — flux de travail basé sur des nœuds pour la vidéo + l’image
* [Interpolation vidéo RIFE](/guides/guides_v2-fr/traitement-video/rife-interpolation.md) — fluidifiez la vidéo générée

***

*Dernière mise à jour : 16 mars 2026 | Article : arXiv:2603.04291 (CVPR 2026) | Basé sur le modèle de fondation Wan2.1*


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-video/cubecomposer-360-video.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.