CubeComposer 4K-360°-Video

CubeComposer (CVPR 2026) ist ein raum-zeitliches autoregressives Diffusionsmodell, das erzeugt natives 4K-360°-Panoramavideo aus standardmäßigem Perspektivvideo als Eingabe. Auf dem Wan-Video-Foundation-Model aufgebaut, trainiert auf 11.832 hochauflösenden Clips. Dies ist das erste offene Modell, das native 4K-360°-Generierung beherrscht — und so die Erstellung von VR-Inhalten, virtuellen Rundgängen und immersiven Medien auf Consumer-GPU-Hardware ermöglicht.

Warum das wichtig ist

360°-Video erforderte traditionell spezielle Aufnahme-Rigs (mehrere Kameras, Stitching-Software, teure Nachbearbeitung). CubeComposer ändert das:

• Eingabe: jedes Standard-Kameravideo (Einzellinsen-, Smartphone- oder Dashcam-Aufnahmen)

• Ausgabe: natives 4K-360°-Equirectangular-Video

• Methode: zerlegt Panoramen in Cubemap-Flächen und erzeugt jede Fläche autoregressiv mit räumlicher Konsistenz

• Qualität: übertrifft frühere Stitching- und Outpainting-Ansätze deutlich

Hardware-Anforderungen

Konfiguration	VRAM	Auflösung	Geschwindigkeit
RTX 4090 24GB	24 GB	4K 360° (30 Frames)	~8 Min./Clip
RTX 5090 32 GB	32 GB	4K 360° (60 Frames)	~6 Min./Clip
2× RTX 4090	48GB	4K 360° (120 Frames)	~9 Min./Clip
A100 80GB	80 GB	4K 360° (240 Frames)	~12 Min./Clip

MinimumRTX 4090 24 GB (oder äquivalente GPU mit 24 GB+ VRAM)

Auf Clore.ai: RTX 4090 ab $0,14–0,42/Stunde Spot — ein 2-minütiger Clip kostet ca. ~$0,40.

Installation

# Repository klonen
git clone https://github.com/TencentARC/CubeComposer
cd cubecomposer

# Abhängigkeiten installieren (Python 3.10+, CUDA 12.8+)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
pip install -r requirements.txt

# Modellgewichte herunterladen (~18 GB)
python scripts/download_weights.py --model cubecomposer-4k-v1

Docker (empfohlen für Clore.ai)

# Kein offizielles Docker-Image — aus dem Quellcode installieren:
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

Schnellstart

CLI: Perspektivvideo → 4K 360°

# Grundlegende Nutzung: Perspektivvideo als Eingabe, 4K-Equirectangular als Ausgabe
python generate_360.py \\
  --input /workspace/input_video.mp4 \\
  --output /workspace/output_360.mp4 \\
  --resolution 4096x2048 \\
  --frames 30 \\
  --fps 30

# Höhere Qualität: mehr Schritte, längerer Clip
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

Python-API

from cubecomposer import CubeComposerPipeline
import torch

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

# Erzeuge 360°-Video aus Perspektivvideo als Eingabe
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),  # 4K-Equirectangular
    num_inference_steps=50,
    guidance_scale=7.5,
    cubemap_size=1024  # Größe jeder Cubemap-Fläche
)

# Als standardmäßiges Equirectangular-MP4 speichern
output.save("output_360.mp4", fps=30)
print(f"Generiertes 4K-360°-Video: output_360.mp4")

Gradio-WebUI

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="Eingabe-Perspektivvideo"),
        gr.Slider(10, 120, value=30, label="Anzahl der Frames"),
        gr.Slider(20, 80, value=50, label="Inference-Schritte (Qualität)")
    ],
    outputs=gr.Video(label="4K-360°-Ausgabe"),
    title="CubeComposer — 4K-360°-Videoerzeugung",
    description="Beliebiges Perspektivvideo hochladen → natives 4K-360°-Panoramavideo erhalten"
)

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

Bereitstellung auf Clore.ai: Schritt für Schritt

1. Miete eine RTX 4090

1. Gehe zu clore.ai/marketplace

2. Filter: GPU mit 24 GB+ VRAM (RTX 4090 empfohlen)

3. Spot-Preis: ca. ~$1,20–2,50/Stunde, je nach Verfügbarkeit

4. Wähle Benutzerdefiniertes Docker oder Ubuntu Image

2. Einrichtung per SSH

# Mit deinem Clore-Server verbinden
ssh root@<server-ip>

# Einzeilige Einrichtung
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. Auf die UI zugreifen

Öffnen http://<server-ip>:7860 in deinem Browser, um die Gradio-Oberfläche zu nutzen.

Workflow: Handyvideo → VR-fähiges 4K-360°

# Schritt 1: Handyvideo auf den Server hochladen
scp ~/my_video.mp4 root@<server-ip>:/workspace/

# Schritt 2: 4K-360°-Version erzeugen
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"

# Schritt 3: 360°-Metadaten für YouTube/VR-Headsets hinzufügen
ffmpeg -i my_video_360_4k.mp4 \\
  -c copy \\
  -metadata:s:v:0 spherical=equirectangular \\
  my_video_360_4k_vr.mp4

# Schritt 4: Ergebnis herunterladen
scp root@<server-ip>:/workspace/my_video_360_4k_vr.mp4 ~/

Spectrum-Integration: 4,79× Beschleunigung auf Wan2.1

Der Spectrum-Beschleuniger (CVPR 2026) — ein trainingsfreier spektraler Diffusions-Feature-Vorhersager mit Tschebyscheff-Polynomen — kann auf die zugrunde liegende Wan2.1-Basis von CubeComposer angewendet werden, um deutliche Beschleunigungen zu erzielen:

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

# Spectrum anwenden für 4,79× Beschleunigung ohne Qualitätsverlust
accelerator = SpectrumAccelerator(pipe.unet, order=8)  # Tschebyscheff-Ordnung
pipe.unet = accelerator

# Erzeugt jetzt mit etwa 4,79× der ursprünglichen Geschwindigkeit
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),
    num_inference_steps=50  # Effektive Qualität von ~240 Schritten
)
output.save("output_fast_360.mp4")

Qualitätstipps

1. Die Qualität des Eingabevideos ist wichtig — höhere Eingabeauflösung = bessere 360°-Ausgabe

2. Stabiles Filmmaterial — Verwacklungen von Hand reduzieren die Konsistenz zwischen den Cubemap-Flächen

3. Gute Beleuchtung — extreme Kontraste vermeiden (überbelichteter Himmel + dunkles Interieur)

4. Längere Clips — 30+ Frames sorgen für bessere zeitliche Konsistenz

5. Flächenauflösung — --cubemap_size 1024 ist der optimale Bereich (2048 für kritische Arbeiten, kostet 4× mehr VRAM)

Anwendungsfälle

• VR-Inhaltserstellung — beliebiges Material für Meta Quest, Apple Vision Pro umwandeln

• Virtuelle Immobilienrundgänge — Rundgangsvideos in 360°-Touren verwandeln

• Reiseinhalte — immersive Reiseerlebnisse teilen

• Architekturvisualisierung — 360°-Innen-/Außenrundgänge

• Event-Dokumentation — Event-Aufzeichnungen in immersive Wiederholungen umwandeln

• Gaming-Assets — 360°-Umgebungsreferenzen erzeugen

Kostenschätzung für den Produktions-Workflow

Aufgabe	Clore.ai-Kosten
5-Sekunden-Clip (30 Frames, 4K)	~0,30 $ (RTX 4090 Spot)
10-Sekunden-Clip (60 Frames, 4K)	~$0.50
30-Sekunden-Clip (180 Frames, 4K)	~$1.20
Batch: 100 Clips (je 5 s)	~$30

Verwandte Leitfäden

• Wan2.1-Videoerzeugung — das Foundation Model hinter CubeComposer

• FramePack — effiziente Erzeugung langer Videos (6 GB VRAM!)

• LTX-2-Video — schnelle latente Videoerzeugung

• ComfyUI — knotenbasierter Workflow für Video + Bild

• RIFE-Video-Interpolation — erzeugtes Video glätten

---

Zuletzt aktualisiert: 16. März 2026 | Paper: arXiv:2603.04291 (CVPR 2026) | Basierend auf dem Wan2.1-Foundation-Model