> 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-es/generacion-de-video/cubecomposer-360-video.md).

# Video CubeComposer 4K 360°

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

## Por qué esto importa

Tradicionalmente, el video 360° ha requerido equipos de captura especializados (múltiples cámaras, software de ensamblado, posprocesamiento costoso). CubeComposer cambia esto:

* **Entrada**: cualquier video de cámara estándar (lente única, cámara de teléfono, cámara de tablero)
* **Salida**: video equirectangular 360° 4K nativo
* **Método**: descompone los panoramas en caras de cubemap y genera cada cara de forma autorregresiva con consistencia espacial
* **Calidad**: supera significativamente los enfoques anteriores de ensamblado 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     | 80 GB | 4K 360° (240 fotogramas) | \~12 min/clip |

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

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

## Instalación

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

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

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

### Docker (recomendado para Clore.ai)

```bash
# No hay una imagen oficial de Docker — instálalo 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")
```

### Interfaz web de 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="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 360° 4K nativo"
)

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

## Despliegue en Clore.ai: paso a paso

### 1. Alquila una RTX 4090

1. Ve a [clore.ai/marketplace](https://clore.ai/marketplace)
2. Filtro: GPU con **24 GB+ 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 mediante 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 interfaz

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

## Flujo de trabajo: video de 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: Genera 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ñade metadatos 360° para YouTube/auriculares VR
ffmpeg -i my_video_360_4k.mp4 \\
  -c copy \\
  -metadata:s:v:0 spherical=equirectangular \\
  my_video_360_4k_vr.mp4

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

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

El **acelerador Spectrum** (CVPR 2026) — un pronosticador de características de difusión espectral sin entrenamiento que utiliza polinomios de Chebyshev — puede aplicarse a la base Wan2.1 subyacente de CubeComposer para lograr 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")

# Aplica 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 entrada de mayor resolución = mejor salida 360°
2. **Metraje estable** — el movimiento de mano reduce la consistencia entre las caras del cubemap
3. **Buena iluminación** — evita contrastes extremos (cielo sobreexpuesto + interior oscuro)
4. **Clips más largos** — 30+ fotogramas dan mejor consistencia temporal
5. **Resolución de las caras** — `--cubemap_size 1024` es el punto óptimo (2048 para trabajos críticos, 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** — convierte videos de recorrido en tours 360°
* **Contenido de viajes** — comparte experiencias de viaje inmersivas
* **Visualización arquitectónica** — recorridos 360° de interiores/exteriores
* **Documentación de eventos** — convierte grabaciones de eventos en repeticiones inmersivas
* **Activos para videojuegos** — genera referencias de entornos 360°

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

| Tarea                                    | Coste de Clore.ai          |
| ---------------------------------------- | -------------------------- |
| Clip de 5 segundos (30 fotogramas, 4K)   | \~$0.30 (spot de 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 Wan2.1](/guides/guides_v2-es/generacion-de-video/wan-video.md) — el modelo fundacional detrás de CubeComposer
* [FramePack](/guides/guides_v2-es/generacion-de-video/framepack.md) — generación eficiente de videos largos (¡6 GB de VRAM!)
* [Video LTX-2](/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 e imagen
* [Interpolación de video RIFE](/guides/guides_v2-es/procesamiento-de-video/rife-interpolation.md) — suavizar el video generado

***

*Última actualización: 16 de marzo de 2026 | Artículo: arXiv:2603.04291 (CVPR 2026) | Basado en el modelo fundacional 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-es/generacion-de-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.