# Video 360° CubeComposer 4K

> **CubeComposer** (CVPR 2026) es un modelo de difusión autorregresivo espaciotemporal que genera **video panorámico nativo 4K de 360°** a partir de una entrada de video estándar en perspectiva. Basado en el modelo fundacional de video Wan, entrenado con 11,832 clips de alta resolución. Este es el primer modelo abierto capaz de generar de forma nativa en 4K 360° — lo que permite la creación de contenido VR, recorridos virtuales y medios inmersivos en hardware de GPU de consumo.

## Por qué esto importa

El video de 360° tradicionalmente requería equipos de captura especializados (múltiples cámaras, software de unión, posprocesamiento costoso). CubeComposer cambia esto:

* **Entrada**: cualquier video estándar de cámara (lente única, cámara de teléfono, dashcam)
* **Salida**: video equirectangular nativo 4K de 360°
* **Método**: descompone los panoramas en caras de un cubemap y genera cada cara de forma autorregresiva con consistencia espacial
* **Calidad**: supera significativamente los enfoques anteriores de unión y outpainting

## Requisitos de hardware

| Configuración | VRAM | Resolución               | Velocidad     |
| ------------- | ---- | ------------------------ | ------------- |
| RTX 4090 24GB | 24GB | 4K 360° (30 fotogramas)  | \~8 min/clip  |
| RTX 5090 32GB | 32GB | 4K 360° (60 fotogramas)  | \~6 min/clip  |
| 2× RTX 4090   | 48GB | 4K 360° (120 fotogramas) | \~9 min/clip  |
| A100 80GB     | 80GB | 4K 360° (240 fotogramas) | \~12 min/clip |

**Mínimo**: RTX 4090 24GB (o GPU equivalente con 24GB+ de VRAM)

> En Clore.ai: RTX 4090 desde **\~$1.20/h spot** — un clip de 2 minutos cuesta \~$0.40.

## Instalación

```bash
# Clonar el repositorio
git clone https://github.com/TencentARC/CubeComposer
cd cubecomposer

# Instalar dependencias (Python 3.10+, CUDA 12.1+)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install -r requirements.txt

# Descargar pesos del modelo (~18GB)
python scripts/download_weights.py --model cubecomposer-4k-v1
```

### Docker (recomendado para Clore.ai)

```bash
# No hay imagen Docker oficial — instalar desde el código fuente:
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
```

## Inicio rápido

### CLI: video en perspectiva → 4K 360°

```bash
# Uso básico: video de entrada en perspectiva, salida equirectangular 4K
python generate_360.py \
  --input /workspace/input_video.mp4 \
  --output /workspace/output_360.mp4 \
  --resolution 4096x2048 \
  --frames 30 \
  --fps 30

# Mayor calidad: más pasos, clip más largo
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 de Python

```python
from cubecomposer import CubeComposerPipeline
import torch

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

# Generar video 360° a partir de una entrada en perspectiva
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),  # equirectangular 4K
    num_inference_steps=50,
    guidance_scale=7.5,
    cubemap_size=1024  # tamaño de cada cara del cubemap
)

# Guardar como MP4 equirectangular estándar
output.save("output_360.mp4", fps=30)
print(f"Video 4K 360° generado: output_360.mp4")
```

### Gradio WebUI

```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="Video de entrada en perspectiva"),
        gr.Slider(10, 120, value=30, label="Número de fotogramas"),
        gr.Slider(20, 80, value=50, label="Pasos de inferencia (calidad)")
    ],
    outputs=gr.Video(label="Salida 4K 360°"),
    title="CubeComposer — Generación de video 4K 360°",
    description="Sube cualquier video en perspectiva → obtén video panorámico nativo 4K 360°"
)

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

## Implementación en Clore.ai: paso a paso

### 1. Alquila una RTX 4090

1. Ve a [clore.ai/marketplace](https://clore.ai/marketplace)
2. Filtrar: GPU con **24GB+ de VRAM** (se recomienda RTX 4090)
3. Precio spot: \~$1.20–2.50/h según disponibilidad
4. Selecciona **Docker personalizado** o **Ubuntu** imagen

### 2. Configuración vía SSH

```bash
# Conéctate a tu servidor de Clore
ssh root@<server-ip>

# Configuración en una sola línea
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. Accede a la UI

Abre `http://<server-ip>:7860` en tu navegador para usar la interfaz de Gradio.

## Flujo de trabajo: video del teléfono → 4K 360° listo para VR

```bash
# Paso 1: sube el video del teléfono al servidor
scp ~/my_video.mp4 root@<server-ip>:/workspace/

# Paso 2: generar la versión 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"

# Paso 3: añadir metadatos 360° para YouTube/visores VR
ffmpeg -i my_video_360_4k.mp4 \
  -c copy \
  -metadata:s:v:0 spherical=equirectangular \
  my_video_360_4k_vr.mp4

# Paso 4: descargar el resultado
scp root@<server-ip>:/workspace/my_video_360_4k_vr.mp4 ~/
```

## Integración con Spectrum: aceleración de 4.79× en Wan2.1

El **acelerador Spectrum** (CVPR 2026) — un predictor de características de difusión espectral sin entrenamiento que utiliza polinomios de Chebyshev — puede aplicarse al Wan2.1 base subyacente de CubeComposer para obtener aceleraciones significativas:

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

# Aplicar Spectrum para una aceleración de 4.79× sin pérdida de calidad
accelerator = SpectrumAccelerator(pipe.unet, order=8)  # orden de Chebyshev
pipe.unet = accelerator

# Ahora genera a ~4.79× la velocidad original
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),
    num_inference_steps=50  # calidad efectiva de ~240 pasos
)
output.save("output_fast_360.mp4")
```

## Consejos de calidad

1. **La calidad del video de entrada importa** — una mayor resolución de entrada = mejor salida 360°
2. **Metraje estable** — el movimiento de cámara en mano reduce la consistencia entre las caras del cubemap
3. **Buena iluminación** — evita el contraste extremo (cielo sobreexpuesto + interior oscuro)
4. **Clips más largos** — 30+ fotogramas ofrecen mejor consistencia temporal
5. **Resolución de las caras** — `--cubemap_size 1024` es el punto ideal (2048 para trabajo crítico, cuesta 4× más VRAM)

## Casos de uso

* **creación de contenido VR** — convierte cualquier metraje para Meta Quest, Apple Vision Pro
* **recorridos virtuales de propiedades** — transforma videos de recorrido en tours de 360°
* **contenido de viajes** — comparte experiencias de viaje inmersivas
* **visualización arquitectónica** — recorridos interiores/exteriores de 360°
* **documentación de eventos** — convierte grabaciones de eventos en reproducciones inmersivas
* **activos para videojuegos** — genera referencias de entornos en 360°

## Estimación de costos para el flujo de trabajo de producción

| Tarea                                    | Costo en Clore.ai       |
| ---------------------------------------- | ----------------------- |
| clip de 5 segundos (30 fotogramas, 4K)   | \~$0.30 (spot RTX 4090) |
| clip de 10 segundos (60 fotogramas, 4K)  | \~$0.50                 |
| clip de 30 segundos (180 fotogramas, 4K) | \~$1.20                 |
| Lote: 100 clips (5 s cada uno)           | \~$30                   |

## Guías relacionadas

* [Generación de video con Wan2.1](/guides/guides_v2-es/generacion-de-video/wan-video.md) — el modelo fundacional bajo CubeComposer
* [FramePack](/guides/guides_v2-es/generacion-de-video/framepack.md) — generación eficiente de video largo (¡6GB de VRAM!)
* [LTX-2 Video](/guides/guides_v2-es/generacion-de-video/ltx-video-2.md) — generación rápida de video latente
* [ComfyUI](/guides/guides_v2-es/generacion-de-imagenes/comfyui.md) — flujo de trabajo basado en nodos para video + imagen
* [Interpolación de video RIFE](/guides/guides_v2-es/procesamiento-de-video/rife-interpolation.md) — suaviza el video generado

***

*Última actualización: 16 de marzo de 2026 | Documento: arXiv:2603.04291 (CVPR 2026) | Basado en el modelo fundacional Wan2.1*


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/cubecomposer-360-video.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.